/// <summary>
/// Gets a FileItem for a given path
/// </summary>
/// <param name="Location">Location of the file</param>
/// <returns>The FileItem that represents the given a full file path.</returns>
public static FileItem GetItemByFileReference(FileReference Location)
{
FileItem Result;
if (!UniqueSourceFileMap.TryGetValue(Location, out Result))
{
FileItem NewFileItem = new FileItem(Location, Location.ToFileInfo());
if (UniqueSourceFileMap.TryAdd(Location, NewFileItem))
{
Result = NewFileItem;
}
else
{
Result = UniqueSourceFileMap[Location];
}
}
return(Result);
}
/// <summary>
/// Parse a list of target descriptors from the command line
/// </summary>
/// <param name="Arguments">Command-line arguments</param>
/// <param name="bUsePrecompiled">Whether to use a precompiled engine distribution</param>
/// <param name="bSkipRulesCompile">Whether to skip compiling rules assemblies</param>
/// <param name="TargetDescriptors">List of target descriptors</param>
public static void ParseSingleCommandLine(CommandLineArguments Arguments, bool bUsePrecompiled, bool bSkipRulesCompile, List <TargetDescriptor> TargetDescriptors)
{
List <UnrealTargetPlatform> Platforms = new List <UnrealTargetPlatform>();
List <UnrealTargetConfiguration> Configurations = new List <UnrealTargetConfiguration>();
List <string> TargetNames = new List <string>();
FileReference ProjectFile = Arguments.GetFileReferenceOrDefault("-Project=", null);
// Settings for creating/using static libraries for the engine
for (int ArgumentIndex = 0; ArgumentIndex < Arguments.Count; ArgumentIndex++)
{
string Argument = Arguments[ArgumentIndex];
if (Argument.Length > 0 && Argument[0] != '-')
{
// Mark this argument as used. We'll interpret it as one thing or another.
Arguments.MarkAsUsed(ArgumentIndex);
// Check if it's a project file argument
if (Argument.EndsWith(".uproject", StringComparison.OrdinalIgnoreCase))
{
FileReference NewProjectFile = new FileReference(Argument);
if (ProjectFile != null && ProjectFile != NewProjectFile)
{
throw new BuildException("Multiple project files specified on command line (first {0}, then {1})", ProjectFile, NewProjectFile);
}
ProjectFile = new FileReference(Argument);
continue;
}
// Split it into separate arguments
string[] InlineArguments = Argument.Split('+');
// Try to parse them as platforms
UnrealTargetPlatform ParsedPlatform;
if (UnrealTargetPlatform.TryParse(InlineArguments[0], out ParsedPlatform))
{
Platforms.Add(ParsedPlatform);
for (int InlineArgumentIdx = 1; InlineArgumentIdx < InlineArguments.Length; InlineArgumentIdx++)
{
Platforms.Add(UnrealTargetPlatform.Parse(InlineArguments[InlineArgumentIdx]));
}
continue;
}
// Try to parse them as configurations
UnrealTargetConfiguration ParsedConfiguration;
if (Enum.TryParse(InlineArguments[0], true, out ParsedConfiguration))
{
Configurations.Add(ParsedConfiguration);
for (int InlineArgumentIdx = 1; InlineArgumentIdx < InlineArguments.Length; InlineArgumentIdx++)
{
string InlineArgument = InlineArguments[InlineArgumentIdx];
if (!Enum.TryParse(InlineArgument, true, out ParsedConfiguration))
{
throw new BuildException("Invalid configuration '{0}'", InlineArgument);
}
Configurations.Add(ParsedConfiguration);
}
continue;
}
// Otherwise assume they are target names
TargetNames.AddRange(InlineArguments);
}
}
if (Platforms.Count == 0)
{
throw new BuildException("No platforms specified for target");
}
if (Configurations.Count == 0)
{
throw new BuildException("No configurations specified for target");
}
// Make sure the project file exists, and make sure we're using the correct case.
if (ProjectFile != null)
{
FileInfo ProjectFileInfo = FileUtils.FindCorrectCase(ProjectFile.ToFileInfo());
if (!ProjectFileInfo.Exists)
{
throw new BuildException("Unable to find project '{0}'.", ProjectFile);
}
ProjectFile = new FileReference(ProjectFileInfo);
}
// Expand all the platforms, architectures and configurations
foreach (UnrealTargetPlatform Platform in Platforms)
{
// Make sure the platform is valid
if (!InstalledPlatformInfo.IsValid(null, Platform, null, EProjectType.Code, InstalledPlatformState.Downloaded))
{
if (!InstalledPlatformInfo.IsValid(null, Platform, null, EProjectType.Code, InstalledPlatformState.Supported))
{
throw new BuildException("The {0} platform is not supported from this engine distribution.", Platform);
}
else
{
throw new BuildException("Missing files required to build {0} targets. Enable {0} as an optional download component in the Epic Games Launcher.", Platform);
}
}
// Parse the architecture parameter, or get the default for the platform
List <string> Architectures = new List <string>(Arguments.GetValues("-Architecture=", '+'));
if (Architectures.Count == 0)
{
Architectures.Add(UEBuildPlatform.GetBuildPlatform(Platform).GetDefaultArchitecture(ProjectFile));
}
foreach (string Architecture in Architectures)
{
foreach (UnrealTargetConfiguration Configuration in Configurations)
{
// Create all the target descriptors for targets specified by type
foreach (string TargetTypeString in Arguments.GetValues("-TargetType="))
{
TargetType TargetType;
if (!Enum.TryParse(TargetTypeString, out TargetType))
{
throw new BuildException("Invalid target type '{0}'", TargetTypeString);
}
if (ProjectFile == null)
{
throw new BuildException("-TargetType=... requires a project file to be specified");
}
else
{
TargetNames.Add(RulesCompiler.CreateProjectRulesAssembly(ProjectFile, bUsePrecompiled, bSkipRulesCompile).GetTargetNameByType(TargetType, Platform, Configuration, Architecture, ProjectFile));
}
}
// Make sure we could parse something
if (TargetNames.Count == 0)
{
throw new BuildException("No target name was specified on the command-line.");
}
// Create all the target descriptors
foreach (string TargetName in TargetNames)
{
// If a project file was not specified see if we can find one
if (ProjectFile == null && NativeProjects.TryGetProjectForTarget(TargetName, out ProjectFile))
{
Log.TraceVerbose("Found project file for {0} - {1}", TargetName, ProjectFile);
}
// Create the target descriptor
TargetDescriptors.Add(new TargetDescriptor(ProjectFile, TargetName, Platform, Configuration, Architecture, Arguments));
}
}
}
}
}
/// <summary>
/// Resets the cached file info
/// </summary>
public void ResetCachedInfo()
{
Info = Location.ToFileInfo();
}