/**
* Get the extension to use for the given binary type
*
* @param InBinaryType The binrary type being built
*
* @return string The binary extenstion (ie 'exe' or 'dll')
*/
public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
{
if (GetActiveArchitecture() == "-win32")
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return ".dll";
case UEBuildBinaryType.Executable:
return ".exe";
case UEBuildBinaryType.StaticLibrary:
return ".lib";
}
return base.GetBinaryExtension(InBinaryType);
}
else
{
if (InBinaryType == UEBuildBinaryType.StaticLibrary)
{
return ".bc";
}
else
{
return ".js";
}
}
}
bool IsBuildingDll(UEBuildBinaryType Type)
{
if (BuildConfiguration.bRunUnrealCodeAnalyzer)
{
return(false);
}
return(Type == UEBuildBinaryType.DynamicLinkLibrary);
}
/// <summary>
/// Get the extension to use for debug info for the given binary type
/// </summary>
/// <param name="Target">The target being built</param>
/// <param name="InBinaryType"> The binary type being built</param>
/// <returns>string The debug info extension (i.e. 'pdb')</returns>
public override string[] GetDebugInfoExtensions(ReadOnlyTargetRules Target, UEBuildBinaryType InBinaryType)
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
case UEBuildBinaryType.Executable:
return(new string[] { ".pdb" });
}
return(new string[] { "" });
}
/// <summary>
/// Get the extension to use for debug info for the given binary type
/// </summary>
/// <param name="InBinaryType"> The binary type being built</param>
/// <returns>string The debug info extension (i.e. 'pdb')</returns>
public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
case UEBuildBinaryType.Executable:
return(".pdb");
}
return("");
}
/// <summary>
/// Get the extensions to use for debug info for the given binary type
/// </summary>
/// <param name="Target">Rules for the target being built</param>
/// <param name="InBinaryType"> The binary type being built</param>
/// <returns>string[] The debug info extensions (i.e. 'pdb')</returns>
public override string[] GetDebugInfoExtensions(ReadOnlyTargetRules Target, UEBuildBinaryType InBinaryType)
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
case UEBuildBinaryType.Executable:
return(Target.bUsePDBFiles ? new string[] { ".dSYM" } : new string[] {});
case UEBuildBinaryType.StaticLibrary:
default:
return(new string [] {});
}
}
/**
* Get the extension to use for the given binary type
*
* @param InBinaryType The binary type being built
*
* @return string The binary extension (i.e. 'exe' or 'dll')
*/
public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return ".dll";
case UEBuildBinaryType.Executable:
return ".exe";
case UEBuildBinaryType.StaticLibrary:
return ".lib";
}
return base.GetBinaryExtension(InBinaryType);
}
public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
{
if (BuildConfiguration.bGeneratedSYMFile)
{
return(".dSYM");
}
if (BuildConfiguration.bGeneratedSYMBundle)
{
return(".dSYM.zip");
}
return("");
}
public override string GetDebugInfoExtension(ReadOnlyTargetRules InTarget, UEBuildBinaryType InBinaryType)
{
IOSProjectSettings ProjectSettings = ReadProjectSettings(InTarget.ProjectFile);
if (ProjectSettings.bGeneratedSYMBundle)
{
return(".dSYM.zip");
}
else if (ProjectSettings.bGeneratedSYMFile)
{
return(".dSYM");
}
return("");
}
/// <summary>
/// Get the extension to use for the given binary type
/// </summary>
/// <param name="InBinaryType"> The binary type being built</param>
/// <returns>string The binary extension (i.e. 'exe' or 'dll')</returns>
public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return(".so");
case UEBuildBinaryType.Executable:
return("");
case UEBuildBinaryType.StaticLibrary:
return(".a");
}
return(base.GetBinaryExtension(InBinaryType));
}
/// <summary>
/// Get the extension to use for the given binary type
/// </summary>
/// <param name="InBinaryType"> The binary type being built</param>
/// <returns>string The binary extension (ie 'exe' or 'dll')</returns>
public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return(".js");
case UEBuildBinaryType.Executable:
return(".js");
case UEBuildBinaryType.StaticLibrary:
return(HTML5ToolChain.libExt);
}
return(base.GetBinaryExtension(InBinaryType));
}
/// <summary>
/// Get the extension to use for the given binary type
/// </summary>
/// <param name="InBinaryType"> The binary type being built</param>
/// <returns>string The binary extension (ie 'exe' or 'dll')</returns>
public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
{
if (HTML5Architecture == "-win32")
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return(".dll");
case UEBuildBinaryType.Executable:
return(".exe");
case UEBuildBinaryType.StaticLibrary:
return(".lib");
case UEBuildBinaryType.Object:
return(".o");
case UEBuildBinaryType.PrecompiledHeader:
return(".gch");
}
return(base.GetBinaryExtension(InBinaryType));
}
else
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return(".js");
case UEBuildBinaryType.Executable:
return(".js");
case UEBuildBinaryType.StaticLibrary:
return(".bc");
case UEBuildBinaryType.Object:
return(".bc");
case UEBuildBinaryType.PrecompiledHeader:
return(".gch");
}
return(base.GetBinaryExtension(InBinaryType));
}
}
/**
* Get the extension to use for the given binary type
*
* @param InBinaryType The binary type being built
*
* @return string The binary extension (i.e. 'exe' or 'dll')
*/
public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return ".dll";
case UEBuildBinaryType.Executable:
return ".exe";
case UEBuildBinaryType.StaticLibrary:
return ".lib";
case UEBuildBinaryType.Object:
return ".obj";
case UEBuildBinaryType.PrecompiledHeader:
return ".pch";
}
return base.GetBinaryExtension(InBinaryType);
}
/// <summary>
/// Create an instance of the class with the given configuration data
/// </summary>
/// <param name="Type"></param>
/// <param name="OutputFilePaths"></param>
/// <param name="IntermediateDirectory"></param>
/// <param name="bAllowExports"></param>
/// <param name="PrimaryModule"></param>
/// <param name="bUsePrecompiled"></param>
public UEBuildBinary(
UEBuildBinaryType Type,
IEnumerable <FileReference> OutputFilePaths,
DirectoryReference IntermediateDirectory,
bool bAllowExports,
UEBuildModuleCPP PrimaryModule,
bool bUsePrecompiled
)
{
this.Type = Type;
this.OutputFilePaths = new List <FileReference>(OutputFilePaths);
this.IntermediateDirectory = IntermediateDirectory;
this.bAllowExports = bAllowExports;
this.PrimaryModule = PrimaryModule;
this.bUsePrecompiled = bUsePrecompiled;
Modules.Add(PrimaryModule);
}
/// <summary>
/// Get the extension to use for debug info for the given binary type
/// </summary>
/// <param name="InBinaryType"> The binary type being built</param>
/// <returns>string The debug info extension (i.e. 'pdb')</returns>
public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
{
if (HTML5Architecture == "-win32")
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return(".pdb");
case UEBuildBinaryType.Executable:
return(".pdb");
}
return("");
}
else
{
return("");
}
}
public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return(".so");
case UEBuildBinaryType.Executable:
return(".so");
case UEBuildBinaryType.StaticLibrary:
return(".a");
case UEBuildBinaryType.Object:
return(".o");
case UEBuildBinaryType.PrecompiledHeader:
return(".gch");
}
return(base.GetBinaryExtension(InBinaryType));
}
/// <summary>
/// Get the extension to use for debug info for the given binary type
/// </summary>
/// <param name="InBinaryType"> The binary type being built</param>
/// <returns>string The debug info extension (i.e. 'pdb')</returns>
public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return(BuildConfiguration.bUsePDBFiles ? ".dSYM" : "");
case UEBuildBinaryType.Executable:
return(BuildConfiguration.bUsePDBFiles ? ".dSYM" : "");
case UEBuildBinaryType.StaticLibrary:
return("");
case UEBuildBinaryType.Object:
return("");
case UEBuildBinaryType.PrecompiledHeader:
return("");
default:
return("");
}
}
/** Given a UBT-built binary name (e.g. "Core"), returns a relative path to the binary for the current build configuration (e.g. "../Binaries/Win64/Core-Win64-Debug.lib") */
public static string[] MakeBinaryPaths(string ModuleName, string BinaryName, UnrealTargetPlatform Platform,
UnrealTargetConfiguration Configuration, UEBuildBinaryType BinaryType, TargetRules.TargetType? TargetType, PluginInfo PluginInfo, string AppName, bool bForceNameAsForDevelopment = false, string ExeBinariesSubFolder = null)
{
// Determine the binary extension for the platform and binary type.
var BuildPlatform = UEBuildPlatform.GetBuildPlatform(Platform);
string BinaryExtension = BuildPlatform.GetBinaryExtension(BinaryType);
UnrealTargetConfiguration LocalConfig = Configuration;
if(Configuration == UnrealTargetConfiguration.DebugGame && !String.IsNullOrEmpty(ModuleName) && !RulesCompiler.IsGameModule(ModuleName))
{
LocalConfig = UnrealTargetConfiguration.Development;
}
string ModuleBinariesSubDir = "";
if (BinaryType == UEBuildBinaryType.DynamicLinkLibrary && (string.IsNullOrEmpty(ModuleName) == false))
{
// Allow for modules to specify sub-folders in the Binaries folder
var RulesFilename = RulesCompiler.GetModuleFilename(ModuleName);
// Plugins can be binary-only and can have no rules object
if (PluginInfo == null || !String.IsNullOrEmpty(RulesFilename))
{
ModuleRules ModuleRulesObj = RulesCompiler.CreateModuleRules(ModuleName, new TargetInfo(Platform, Configuration, TargetType), out RulesFilename);
if (ModuleRulesObj != null)
{
ModuleBinariesSubDir = ModuleRulesObj.BinariesSubFolder;
}
}
}
else if ( BinaryType == UEBuildBinaryType.Executable && string.IsNullOrEmpty(ExeBinariesSubFolder) == false )
{
ModuleBinariesSubDir = ExeBinariesSubFolder;
}
//@todo.Rocket: This just happens to work since exp and lib files go into intermediate...
// Build base directory string ("../Binaries/<Platform>/")
string BinariesDirName;
if(TargetType.HasValue && TargetType.Value == TargetRules.TargetType.Program && UnrealBuildTool.HasUProjectFile() && !ProjectFileGenerator.bGenerateProjectFiles)
{
BinariesDirName = Path.Combine( UnrealBuildTool.GetUProjectPath(), "Binaries" );
}
else if( PluginInfo != null )
{
BinariesDirName = Path.Combine( PluginInfo.Directory, "Binaries" );
}
else
{
BinariesDirName = Path.Combine( "..", "Binaries" );
}
var BaseDirectory = Path.Combine( BinariesDirName, Platform.ToString());
if (ModuleBinariesSubDir.Length > 0)
{
BaseDirectory = Path.Combine(BaseDirectory, ModuleBinariesSubDir);
}
string BinarySuffix = "";
if ((PluginInfo != null) && (BinaryType != UEBuildBinaryType.DynamicLinkLibrary))
{
BinarySuffix = "-Static";
}
// append the architecture to the end of the binary name
BinarySuffix = BuildPlatform.ApplyArchitectureName(BinarySuffix);
string OutBinaryPath = "";
// Append binary file name
string Prefix = "";
if (Platform == UnrealTargetPlatform.Linux && (BinaryType == UEBuildBinaryType.DynamicLinkLibrary || BinaryType == UEBuildBinaryType.StaticLibrary))
{
Prefix = "lib";
}
if (LocalConfig == UnrealTargetConfiguration.Development || bForceNameAsForDevelopment)
{
OutBinaryPath = Path.Combine(BaseDirectory, String.Format("{3}{0}{1}{2}", BinaryName, BinarySuffix, BinaryExtension, Prefix));
}
else
{
OutBinaryPath = Path.Combine(BaseDirectory, String.Format("{5}{0}-{1}-{2}{3}{4}",
BinaryName, Platform.ToString(), LocalConfig.ToString(), BinarySuffix, BinaryExtension, Prefix));
}
return BuildPlatform.FinalizeBinaryPaths(OutBinaryPath);
}
/// <summary>
/// Adds a binary for the given module. Does not check whether a binary already exists, or whether a binary should be created for this build configuration.
/// </summary>
/// <param name="ModuleName">Name of the binary</param>
/// <param name="BinaryType">Type of binary to be created</param>
/// <param name="bAllowCompilation">Whether this binary can be compiled. The function will check whether plugin binaries can be compiled.</param>
/// <param name="bIsCrossTarget">True if module is for supporting a different target-platform</param>
/// <returns>The new binary</returns>
private UEBuildBinaryCPP AddBinaryForModule(string ModuleName, UEBuildBinaryType BinaryType, bool bAllowCompilation, bool bIsCrossTarget)
{
// Get the plugin info for this module
PluginInfo Plugin = FindPluginForModule(ModuleName);
// Get the root output directory and base name (target name/app name) for this binary
string BaseOutputDirectory;
if(Plugin != null)
{
BaseOutputDirectory = Path.GetFullPath(Plugin.Directory);
}
else if(RulesCompiler.IsGameModule(ModuleName) || !bUseSharedBuildEnvironment)
{
BaseOutputDirectory = Path.GetFullPath(ProjectDirectory);
}
else
{
BaseOutputDirectory = Path.GetFullPath(BuildConfiguration.RelativeEnginePath);
}
// Get the configuration that this module will be built in. Engine modules compiled in DebugGame will use Development.
UnrealTargetConfiguration ModuleConfiguration = Configuration;
if(Configuration == UnrealTargetConfiguration.DebugGame && !RulesCompiler.IsGameModule(ModuleName))
{
ModuleConfiguration = UnrealTargetConfiguration.Development;
}
// Get the output and intermediate directories for this module
string OutputDirectory = Path.Combine(BaseOutputDirectory, "Binaries", Platform.ToString());
string IntermediateDirectory = Path.Combine(BaseOutputDirectory, BuildConfiguration.PlatformIntermediateFolder, AppName, ModuleConfiguration.ToString());
// Append a subdirectory if the module rules specifies one
ModuleRules ModuleRules;
if(RulesCompiler.TryCreateModuleRules(ModuleName, TargetInfo, out ModuleRules) && !String.IsNullOrEmpty(ModuleRules.BinariesSubFolder))
{
OutputDirectory = Path.Combine(OutputDirectory, ModuleRules.BinariesSubFolder);
IntermediateDirectory = Path.Combine(IntermediateDirectory, ModuleRules.BinariesSubFolder);
}
// Get the output filenames
string BaseBinaryPath = Path.Combine(OutputDirectory, MakeBinaryFileName(AppName + "-" + ModuleName, Platform, ModuleConfiguration, Rules.UndecoratedConfiguration, BinaryType));
string[] OutputFilePaths = UEBuildPlatform.GetBuildPlatform(Platform).FinalizeBinaryPaths(BaseBinaryPath);
// Prepare the configuration object
UEBuildBinaryConfiguration Config = new UEBuildBinaryConfiguration(BinaryType);
Config.OutputFilePaths = OutputFilePaths;
Config.IntermediateDirectory = IntermediateDirectory;
Config.bHasModuleRules = (ModuleRules != null);
Config.bAllowExports = (BinaryType == UEBuildBinaryType.DynamicLinkLibrary);
Config.bAllowCompilation = bAllowCompilation;
Config.bIsCrossTarget = bIsCrossTarget;
Config.ModuleNames.Add(ModuleName);
// Create the new binary
UEBuildBinaryCPP Binary = new UEBuildBinaryCPP(this, Config);
AppBinaries.Add(Binary);
return Binary;
}
bool IsBuildingLibrary(UEBuildBinaryType Type)
{
if (BuildConfiguration.bRunUnrealCodeAnalyzer)
{
return false;
}
return Type == UEBuildBinaryType.StaticLibrary;
}
public override string[] GetDebugInfoExtensions(ReadOnlyTargetRules InTarget, UEBuildBinaryType InBinaryType)
{
if (InTarget.IOSPlatform.bGeneratedSYM)
{
IOSProjectSettings ProjectSettings = ReadProjectSettings(InTarget.ProjectFile);
// which format?
if (ProjectSettings.bGeneratedSYMBundle)
{
return(new string[] { ".dSYM.zip" });
}
else
{
return(new string[] { ".dSYM" });
}
}
return(new string [] {});
}
/**
* Get the extension to use for debug info for the given binary type
*
* @param InBinaryType The binary type being built
*
* @return string The debug info extension (i.e. 'pdb')
*/
public override string GetDebugInfoExtension( UEBuildBinaryType InBinaryType )
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
case UEBuildBinaryType.Executable:
return ".pdb";
}
return "";
}
/// <summary>
/// Get the extension to use for the given binary type
/// </summary>
/// <param name="InBinaryType"> The binary type being built</param>
/// <returns>string The binary extension (ie 'exe' or 'dll')</returns>
public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
{
if (HTML5Architecture == "-win32")
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return ".dll";
case UEBuildBinaryType.Executable:
return ".exe";
case UEBuildBinaryType.StaticLibrary:
return ".lib";
case UEBuildBinaryType.Object:
return ".o";
case UEBuildBinaryType.PrecompiledHeader:
return ".gch";
}
return base.GetBinaryExtension(InBinaryType);
}
else
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return ".js";
case UEBuildBinaryType.Executable:
return ".js";
case UEBuildBinaryType.StaticLibrary:
return ".bc";
case UEBuildBinaryType.Object:
return ".bc";
case UEBuildBinaryType.PrecompiledHeader:
return ".gch";
}
return base.GetBinaryExtension(InBinaryType);
}
}
/** Given a UBT-built binary name (e.g. "Core"), returns a relative path to the binary for the current build configuration (e.g. "../../Binaries/Win64/Core-Win64-Debug.lib") */
public string[] MakeBinaryPaths(string ModuleName, string BinaryName, UEBuildBinaryType BinaryType, TargetRules.TargetType? TargetType, PluginInfo PluginInfo, string AppName, bool bForceNameAsForDevelopment = false, string ExeBinariesSubFolder = null)
{
if (String.IsNullOrEmpty(ModuleName) && Configuration == UnrealTargetConfiguration.DebugGame && !bCompileMonolithic)
{
return MakeBinaryPaths(ModuleName, BinaryName, Platform, UnrealTargetConfiguration.Development, BinaryType, TargetType, PluginInfo, AppName, bForceNameAsForDevelopment);
}
else
{
return MakeBinaryPaths(ModuleName, BinaryName, Platform, Configuration, BinaryType, TargetType, PluginInfo, AppName, bForceNameAsForDevelopment, ExeBinariesSubFolder);
}
}
/// <summary>
/// The configuration class for a binary build.
/// </summary>
/// <param name="InType"></param>
/// <param name="InOutputFilePath"></param>
/// <param name="bInAllowExports"></param>
/// <param name="bInCreateImportLibrarySeparately"></param>
/// <param name="bInIsCrossTarget">For most binaries, this is false. If this is a cross-platform binary build for a specific platform (for example XB1 DLL for a windows editor) this will be true.</param>
/// <param name="InProjectFilePath"></param>
/// <param name="InModuleNames"></param>
public UEBuildBinaryConfiguration(
UEBuildBinaryType InType,
string InOutputFilePath = null,
string InIntermediateDirectory = null,
bool bInAllowExports = false,
bool bInCreateImportLibrarySeparately = false,
bool bInIncludeDependentLibrariesInLibrary = false,
bool bInAllowCompilation = true,
bool bInIsCrossTarget = false,
bool bInCompileMonolithic = false,
UnrealTargetConfiguration InTargetConfiguration = UnrealTargetConfiguration.Development,
string InTargetName = "",
string InProjectFilePath = "",
List<string> InModuleNames = null
)
{
Type = InType;
OutputFilePath = InOutputFilePath;
IntermediateDirectory = InIntermediateDirectory;
bAllowExports = bInAllowExports;
bCreateImportLibrarySeparately = bInCreateImportLibrarySeparately;
bIncludeDependentLibrariesInLibrary = bInIncludeDependentLibrariesInLibrary;
bAllowCompilation = bInAllowCompilation;
bIsCrossTarget = bInIsCrossTarget;
bCompileMonolithic = bInCompileMonolithic;
TargetConfiguration = InTargetConfiguration;
TargetName = InTargetName;
ProjectFilePath = InProjectFilePath;
ModuleNames = InModuleNames;
}
// UEBuildBinary interface.
bool IsBuildingDll(UEBuildBinaryType Type)
{
return(Type == UEBuildBinaryType.DynamicLinkLibrary);
}
/// <summary>
/// The configuration class for a binary build.
/// </summary>
/// <param name="InType"></param>
/// <param name="InOutputFilePath"></param>
/// <param name="bInAllowExports"></param>
/// <param name="bInCreateImportLibrarySeparately"></param>
/// <param name="bInIsCrossTarget">For most binaries, this is false. If this is a cross-platform binary build for a specific platform (for example XB1 DLL for a windows editor) this will be true.</param>
/// <param name="InProjectFilePath"></param>
/// <param name="InModuleNames"></param>
public UEBuildBinaryConfiguration(
UEBuildBinaryType InType,
IEnumerable<FileReference> InOutputFilePaths = null,
DirectoryReference InIntermediateDirectory = null,
bool bInAllowExports = false,
bool bInCreateImportLibrarySeparately = false,
bool bInIncludeDependentLibrariesInLibrary = false,
bool bInAllowCompilation = true,
bool bInHasModuleRules = true,
bool bInIsCrossTarget = false,
FileReference InProjectFilePath = null,
IEnumerable<string> InModuleNames = null
)
{
Type = InType;
if (InOutputFilePaths != null)
{
OutputFilePaths.AddRange(InOutputFilePaths);
}
IntermediateDirectory = InIntermediateDirectory;
bAllowExports = bInAllowExports;
bCreateImportLibrarySeparately = bInCreateImportLibrarySeparately;
bIncludeDependentLibrariesInLibrary = bInIncludeDependentLibrariesInLibrary;
bAllowCompilation = bInAllowCompilation;
bHasModuleRules = bInHasModuleRules;
bIsCrossTarget = bInIsCrossTarget;
ProjectFilePath = InProjectFilePath;
if (InModuleNames != null)
{
ModuleNames.AddRange(InModuleNames);
}
}
/// <summary>
/// Get the extension to use for debug info for the given binary type
/// </summary>
/// <param name="InTarget">Options for the target being built</param>
/// <param name="InBinaryType"> The binary type being built</param>
/// <returns>string The debug info extension (i.e. 'pdb')</returns>
public virtual string GetDebugInfoExtension(ReadOnlyTargetRules InTarget, UEBuildBinaryType InBinaryType)
{
throw new BuildException("GetDebugInfoExtension for {0} not handled in {1}", InBinaryType.ToString(), this.ToString());
}
/// <summary>
/// Get the extension to use for the given binary type
/// </summary>
/// <param name="InBinaryType"> The binary type being built</param>
/// <returns>string The binary extension (i.e. 'exe' or 'dll')</returns>
public virtual string GetBinaryExtension(UEBuildBinaryType InBinaryType)
{
throw new BuildException("GetBinaryExtensiton for {0} not handled in {1}", InBinaryType.ToString(), this.ToString());
}
/**
* Get the extension to use for debug info for the given binary type
*
* @param InBinaryType The binary type being built
*
* @return string The debug info extension (i.e. 'pdb')
*/
public virtual string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
{
throw new BuildException("GetDebugInfoExtension for {0} not handled in {1}", InBinaryType.ToString(), this.ToString());
}
public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
{
return(BuildConfiguration.bGeneratedSYMFile ? ".dSYM" : "");
}
/// <summary>
/// Get the extension to use for debug info for the given binary type
/// </summary>
/// <param name="InTarget">Rules for the target being built</param>
/// <param name="InBinaryType"> The binary type being built</param>
/// <returns>string The debug info extension (i.e. 'pdb')</returns>
public override string GetDebugInfoExtension(ReadOnlyTargetRules InTarget, UEBuildBinaryType InBinaryType)
{
return("");
}
/// <summary>
/// Makes a filename (without path) for a compiled binary (e.g. "Core-Win64-Debug.lib") */
/// </summary>
/// <param name="BinaryName">The name of this binary</param>
/// <param name="Platform">The platform being built for</param>
/// <param name="Configuration">The configuration being built</param>
/// <param name="UndecoratedConfiguration">The target configuration which doesn't require a platform and configuration suffix. Development by default.</param>
/// <param name="BinaryType">Type of binary</param>
/// <returns>Name of the binary</returns>
public static string MakeBinaryFileName(string BinaryName, UnrealTargetPlatform Platform, UnrealTargetConfiguration Configuration, UnrealTargetConfiguration UndecoratedConfiguration, UEBuildBinaryType BinaryType)
{
StringBuilder Result = new StringBuilder();
if (Platform == UnrealTargetPlatform.Linux && (BinaryType == UEBuildBinaryType.DynamicLinkLibrary || BinaryType == UEBuildBinaryType.StaticLibrary))
{
Result.Append("lib");
}
Result.Append(BinaryName);
if(Configuration != UndecoratedConfiguration)
{
Result.AppendFormat("-{0}-{1}", Platform.ToString(), Configuration.ToString());
}
IUEBuildPlatform BuildPlatform = UEBuildPlatform.GetBuildPlatform(Platform);
Result.Append(BuildPlatform.ApplyArchitectureName(""));
if (BuildConfiguration.bRunUnrealCodeAnalyzer)
{
Result.AppendFormat("-{0}.analysis", BuildConfiguration.UCAModuleToAnalyze);
}
else
{
Result.Append(BuildPlatform.GetBinaryExtension(BinaryType));
}
return Result.ToString();
}
/**
* Get the extension to use for debug info for the given binary type
*
* @param InBinaryType The binary type being built
*
* @return string The debug info extension (i.e. 'pdb')
*/
public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
{
return ".pdb";
}
/// <summary>
/// Get the extensions to use for debug info for the given binary type
/// </summary>
/// <param name="InTarget">Rules for the target being built</param>
/// <param name="InBinaryType"> The binary type being built</param>
/// <returns>string[] The debug info extensions (i.e. 'pdb')</returns>
public override string[] GetDebugInfoExtensions(ReadOnlyTargetRules InTarget, UEBuildBinaryType InBinaryType)
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
case UEBuildBinaryType.Executable:
if (InTarget.LinuxPlatform.bPreservePSYM)
{
return(new string[] { ".psym", ".sym", ".debug" });
}
else
{
return(new string[] { ".sym", ".debug" });
}
}
return(new string [] {});
}
/**
* Get the extension to use for the given binary type
*
* @param InBinaryType The binrary type being built
*
* @return string The binary extenstion (ie 'exe' or 'dll')
*/
public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return ".dll";
case UEBuildBinaryType.Executable:
return ".exe";
case UEBuildBinaryType.StaticLibrary:
return ".lib";
case UEBuildBinaryType.Object:
if (!BuildConfiguration.bRunUnrealCodeAnalyzer)
{
return ".obj";
}
else
{
return @".includes";
}
case UEBuildBinaryType.PrecompiledHeader:
return ".pch";
}
return base.GetBinaryExtension(InBinaryType);
}
/**
* Get the extension to use for debug info for the given binary type
*
* @param InBinaryType The binary type being built
*
* @return string The debug info extension (i.e. 'pdb')
*/
public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return BuildConfiguration.bGeneratedSYMFile || BuildConfiguration.bUsePDBFiles ? ".dsym" : "";
case UEBuildBinaryType.Executable:
return BuildConfiguration.bGeneratedSYMFile || BuildConfiguration.bUsePDBFiles ? ".dsym" : "";
case UEBuildBinaryType.StaticLibrary:
return "";
case UEBuildBinaryType.Object:
return "";
case UEBuildBinaryType.PrecompiledHeader:
return "";
default:
return "";
}
}
/**
* Get the extension to use for debug info for the given binary type
*
* @param InBinaryType The binary type being built
*
* @return string The debug info extension (i.e. 'pdb')
*/
public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
{
return(".pdb");
}
/// <summary>
/// The configuration class for a binary build.
/// </summary>
/// <param name="InType"></param>
/// <param name="InOutputFilePath"></param>
/// <param name="bInAllowExports"></param>
/// <param name="bInCreateImportLibrarySeparately"></param>
/// <param name="bInIsCrossTarget">For most binaries, this is false. If this is a cross-platform binary build for a specific platform (for example XB1 DLL for a windows editor) this will be true.</param>
/// <param name="InProjectFilePath"></param>
/// <param name="InModuleNames"></param>
public UEBuildBinaryConfiguration(
UEBuildBinaryType InType,
string[] InOutputFilePaths = null,
string InIntermediateDirectory = null,
bool bInAllowExports = false,
bool bInCreateImportLibrarySeparately = false,
bool bInIncludeDependentLibrariesInLibrary = false,
bool bInAllowCompilation = true,
bool bInHasModuleRules = true,
bool bInIsCrossTarget = false,
string InProjectFilePath = "",
List<string> InModuleNames = null
)
{
Type = InType;
OutputFilePaths = InOutputFilePaths != null ? (string[])InOutputFilePaths.Clone() : null;
IntermediateDirectory = InIntermediateDirectory;
bAllowExports = bInAllowExports;
bCreateImportLibrarySeparately = bInCreateImportLibrarySeparately;
bIncludeDependentLibrariesInLibrary = bInIncludeDependentLibrariesInLibrary;
bAllowCompilation = bInAllowCompilation;
bHasModuleRules = bInHasModuleRules;
bIsCrossTarget = bInIsCrossTarget;
ProjectFilePath = InProjectFilePath;
if(InModuleNames != null)
{
ModuleNames.AddRange(InModuleNames);
}
}
public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
{
return BuildConfiguration.bGeneratedSYMFile ? ".dSYM" : "";
}
public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
{
if(BuildConfiguration.bGeneratedSYMFile)
{
return ".dSYM";
}
if(BuildConfiguration.bGeneratedSYMBundle)
{
return ".dSYM.zip";
}
return "";
}
bool IsBuildingLibrary(UEBuildBinaryType Type)
{
return(Type == UEBuildBinaryType.StaticLibrary);
}
/**
* Get the extension to use for debug info for the given binary type
*
* @param InBinaryType The binary type being built
*
* @return string The debug info extension (i.e. 'pdb')
*/
public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
{
if (GetActiveArchitecture() == "-win32")
{
switch (InBinaryType)
{
case UEBuildBinaryType.DynamicLinkLibrary:
return ".pdb";
case UEBuildBinaryType.Executable:
return ".pdb";
}
return "";
}
else
{
return "";
}
}
public override string[] GetDebugInfoExtensions(ReadOnlyTargetRules InTarget, UEBuildBinaryType InBinaryType)
{
return(new string [] {});
}
public static string GetPluginSubfolderName(UEBuildBinaryType InBinaryType, string InTargetName)
{
string SubFolderName = Path.Combine("Dynamic", InTargetName);
if (InBinaryType != UEBuildBinaryType.DynamicLinkLibrary)
{
SubFolderName = Path.Combine("Static", InTargetName);
}
return SubFolderName;
}
