/// <summary>
/// Write C++ toolchain information to JSON writer
/// </summary>
/// <param name="Target"></param>
/// <param name="Writer"></param>
private static void ExportEnvironmentToJson(UEBuildTarget Target, JsonWriter Writer)
{
CppCompileEnvironment GlobalCompileEnvironment = Target.CreateCompileEnvironmentForProjectFiles();
Writer.WriteArrayStart("EnvironmentIncludePaths");
foreach (DirectoryReference Path in GlobalCompileEnvironment.UserIncludePaths)
{
Writer.WriteValue(Path.FullName);
}
foreach (DirectoryReference Path in GlobalCompileEnvironment.SystemIncludePaths)
{
Writer.WriteValue(Path.FullName);
}
// TODO: get corresponding includes for specific platforms
if (UEBuildPlatform.IsPlatformInGroup(Target.Platform, UnrealPlatformGroup.Windows))
{
foreach (DirectoryReference Path in Target.Rules.WindowsPlatform.Environment.IncludePaths)
{
Writer.WriteValue(Path.FullName);
}
}
Writer.WriteArrayEnd();
Writer.WriteArrayStart("EnvironmentDefinitions");
foreach (string Definition in GlobalCompileEnvironment.Definitions)
{
Writer.WriteValue(Definition);
}
Writer.WriteArrayEnd();
}
/// <summary>
/// Write a Target to a JSON writer. Is array is empty, don't write anything
/// </summary>
/// <param name="Target"></param>
/// <param name="Writer">Writer for the array data</param>
private static void ExportTarget(UEBuildTarget Target, JsonWriter Writer)
{
Writer.WriteObjectStart();
Writer.WriteValue("Name", Target.TargetName);
Writer.WriteValue("Configuration", Target.Configuration.ToString());
Writer.WriteValue("Platform", Target.Platform.ToString());
Writer.WriteValue("TargetFile", Target.TargetRulesFile.FullName);
if (Target.ProjectFile != null)
{
Writer.WriteValue("ProjectFile", Target.ProjectFile.FullName);
}
ExportEnvironmentToJson(Target, Writer);
if (Target.Binaries.Any())
{
Writer.WriteArrayStart("Binaries");
foreach (UEBuildBinary Binary in Target.Binaries)
{
Writer.WriteObjectStart();
ExportBinary(Binary, Writer);
Writer.WriteObjectEnd();
}
Writer.WriteArrayEnd();
}
CppCompileEnvironment GlobalCompileEnvironment = Target.CreateCompileEnvironmentForProjectFiles();
HashSet <string> ModuleNames = new HashSet <string>();
Writer.WriteObjectStart("Modules");
foreach (UEBuildBinary Binary in Target.Binaries)
{
CppCompileEnvironment BinaryCompileEnvironment = Binary.CreateBinaryCompileEnvironment(GlobalCompileEnvironment);
foreach (UEBuildModule Module in Binary.Modules)
{
if (ModuleNames.Add(Module.Name))
{
Writer.WriteObjectStart(Module.Name);
ExportModule(Module, Binary.OutputDir, Target.GetExecutableDir(), Writer);
UEBuildModuleCPP ModuleCpp = Module as UEBuildModuleCPP;
if (ModuleCpp != null)
{
CppCompileEnvironment ModuleCompileEnvironment = ModuleCpp.CreateCompileEnvironmentForIntellisense(Target.Rules, BinaryCompileEnvironment);
ExportModuleCpp(ModuleCpp, ModuleCompileEnvironment, Writer);
}
Writer.WriteObjectEnd();
}
}
}
Writer.WriteObjectEnd();
ExportPluginsFromTarget(Target, Writer);
Writer.WriteObjectEnd();
}
/// <summary>
/// Write C++ toolchain information to JSON writer
/// </summary>
/// <param name="Target"></param>
/// <param name="Writer"></param>
private void ExportEnvironmentToJson(UEBuildTarget Target, JsonWriter Writer)
{
CppCompileEnvironment GlobalCompileEnvironment = Target.CreateCompileEnvironmentForProjectFiles();
RootToolchainInfo = GenerateToolchainInfo(GlobalCompileEnvironment);
Writer.WriteObjectStart("ToolchainInfo");
foreach (Tuple <string, object> Field in RootToolchainInfo.GetFields())
{
WriteField(Target.TargetName, Writer, Field);
}
Writer.WriteObjectEnd();
Writer.WriteArrayStart("EnvironmentIncludePaths");
foreach (DirectoryReference Path in GlobalCompileEnvironment.UserIncludePaths)
{
Writer.WriteValue(Path.FullName);
}
foreach (DirectoryReference Path in GlobalCompileEnvironment.SystemIncludePaths)
{
Writer.WriteValue(Path.FullName);
}
if (UEBuildPlatform.IsPlatformInGroup(Target.Platform, UnrealPlatformGroup.Windows))
{
foreach (DirectoryReference Path in Target.Rules.WindowsPlatform.Environment.IncludePaths)
{
Writer.WriteValue(Path.FullName);
}
}
else if (UEBuildPlatform.IsPlatformInGroup(Target.Platform, UnrealPlatformGroup.Apple) &&
UEBuildPlatform.IsPlatformInGroup(BuildHostPlatform.Current.Platform, UnrealPlatformGroup.Apple))
{
// Only generate Apple system include paths when host platform is Apple OS
// TODO: Fix case when working with MacOS on Windows host platform
foreach (string Path in AppleHelper.GetAppleSystemIncludePaths(GlobalCompileEnvironment.Architecture, Target.Platform))
{
Writer.WriteValue(Path);
}
}
// TODO: get corresponding includes for Linux
Writer.WriteArrayEnd();
Writer.WriteArrayStart("EnvironmentDefinitions");
foreach (string Definition in GlobalCompileEnvironment.Definitions)
{
Writer.WriteValue(Definition);
}
Writer.WriteArrayEnd();
}
/// <summary>
/// Write C++ toolchain information to JSON writer
/// </summary>
/// <param name="Target"></param>
/// <param name="Writer"></param>
private void ExportEnvironmentToJson(UEBuildTarget Target, JsonWriter Writer)
{
CppCompileEnvironment GlobalCompileEnvironment = Target.CreateCompileEnvironmentForProjectFiles();
RootToolchainInfo = GenerateToolchainInfo(GlobalCompileEnvironment);
Writer.WriteObjectStart("ToolchainInfo");
foreach (Tuple <string, object> Field in RootToolchainInfo.GetFields())
{
WriteField(Target.TargetName, Writer, Field);
}
Writer.WriteObjectEnd();
Writer.WriteArrayStart("EnvironmentIncludePaths");
foreach (DirectoryReference Path in GlobalCompileEnvironment.UserIncludePaths)
{
Writer.WriteValue(Path.FullName);
}
foreach (DirectoryReference Path in GlobalCompileEnvironment.SystemIncludePaths)
{
Writer.WriteValue(Path.FullName);
}
// TODO: get corresponding includes for specific platforms
if (UEBuildPlatform.IsPlatformInGroup(Target.Platform, UnrealPlatformGroup.Windows))
{
foreach (DirectoryReference Path in Target.Rules.WindowsPlatform.Environment.IncludePaths)
{
Writer.WriteValue(Path.FullName);
}
}
Writer.WriteArrayEnd();
Writer.WriteArrayStart("EnvironmentDefinitions");
foreach (string Definition in GlobalCompileEnvironment.Definitions)
{
Writer.WriteValue(Definition);
}
Writer.WriteArrayEnd();
}
/// <summary>
/// Execute the command
/// </summary>
/// <param name="Arguments">Command line arguments</param>
/// <returns>Exit code</returns>
public override int Execute(CommandLineArguments Arguments)
{
Arguments.ApplyTo(this);
// Create the build configuration object, and read the settings
BuildConfiguration BuildConfiguration = new BuildConfiguration();
XmlConfig.ApplyTo(BuildConfiguration);
Arguments.ApplyTo(BuildConfiguration);
// Parse the filter argument
FileFilter FileFilter = null;
if (FilterRules.Count > 0)
{
FileFilter = new FileFilter(FileFilterType.Exclude);
foreach (string FilterRule in FilterRules)
{
FileFilter.AddRules(FilterRule.Split(';'));
}
}
// Parse all the target descriptors
List <TargetDescriptor> TargetDescriptors = TargetDescriptor.ParseCommandLine(Arguments, BuildConfiguration.bUsePrecompiled, BuildConfiguration.bSkipRulesCompile);
// Generate the compile DB for each target
using (ISourceFileWorkingSet WorkingSet = new EmptySourceFileWorkingSet())
{
// Find the compile commands for each file in the target
Dictionary <FileReference, string> FileToCommand = new Dictionary <FileReference, string>();
foreach (TargetDescriptor TargetDescriptor in TargetDescriptors)
{
// Disable PCHs and unity builds for the target
TargetDescriptor.AdditionalArguments = TargetDescriptor.AdditionalArguments.Append(new string[] { "-NoPCH", "-DisableUnity" });
// Create a makefile for the target
UEBuildTarget Target = UEBuildTarget.Create(TargetDescriptor, BuildConfiguration.bSkipRulesCompile, BuildConfiguration.bUsePrecompiled);
// Find the location of the compiler
VCEnvironment Environment = VCEnvironment.Create(WindowsCompiler.Clang, Target.Platform, Target.Rules.WindowsPlatform.Architecture, null, Target.Rules.WindowsPlatform.WindowsSdkVersion, null);
FileReference ClangPath = FileReference.Combine(Environment.CompilerDir, "bin", "clang++.exe");
// Convince each module to output its generated code include path
foreach (UEBuildBinary Binary in Target.Binaries)
{
foreach (UEBuildModuleCPP Module in Binary.Modules.OfType <UEBuildModuleCPP>())
{
Module.bAddGeneratedCodeIncludePath = true;
}
}
// Create all the binaries and modules
CppCompileEnvironment GlobalCompileEnvironment = Target.CreateCompileEnvironmentForProjectFiles();
foreach (UEBuildBinary Binary in Target.Binaries)
{
CppCompileEnvironment BinaryCompileEnvironment = Binary.CreateBinaryCompileEnvironment(GlobalCompileEnvironment);
foreach (UEBuildModuleCPP Module in Binary.Modules.OfType <UEBuildModuleCPP>())
{
if (!Module.Rules.bUsePrecompiled)
{
UEBuildModuleCPP.InputFileCollection InputFileCollection = Module.FindInputFiles(Target.Platform, new Dictionary <DirectoryItem, FileItem[]>());
List <FileItem> InputFiles = new List <FileItem>();
InputFiles.AddRange(InputFileCollection.CPPFiles);
InputFiles.AddRange(InputFileCollection.CCFiles);
CppCompileEnvironment ModuleCompileEnvironment = Module.CreateModuleCompileEnvironment(Target.Rules, BinaryCompileEnvironment);
StringBuilder CommandBuilder = new StringBuilder();
CommandBuilder.AppendFormat("\"{0}\"", ClangPath.FullName);
foreach (FileItem ForceIncludeFile in ModuleCompileEnvironment.ForceIncludeFiles)
{
CommandBuilder.AppendFormat(" -include \"{0}\"", ForceIncludeFile.FullName);
}
foreach (string Definition in ModuleCompileEnvironment.Definitions)
{
CommandBuilder.AppendFormat(" -D\"{0}\"", Definition);
}
foreach (DirectoryReference IncludePath in ModuleCompileEnvironment.UserIncludePaths)
{
CommandBuilder.AppendFormat(" -I\"{0}\"", IncludePath);
}
foreach (DirectoryReference IncludePath in ModuleCompileEnvironment.SystemIncludePaths)
{
CommandBuilder.AppendFormat(" -I\"{0}\"", IncludePath);
}
foreach (FileItem InputFile in InputFiles)
{
if (FileFilter == null || FileFilter.Matches(InputFile.Location.MakeRelativeTo(UnrealBuildTool.RootDirectory)))
{
FileToCommand[InputFile.Location] = String.Format("{0} \"{1}\"", CommandBuilder, InputFile.FullName);
}
}
}
}
}
}
// Write the compile database
FileReference DatabaseFile = FileReference.Combine(UnrealBuildTool.RootDirectory, "compile_commands.json");
using (JsonWriter Writer = new JsonWriter(DatabaseFile))
{
Writer.WriteArrayStart();
foreach (KeyValuePair <FileReference, string> FileCommandPair in FileToCommand.OrderBy(x => x.Key.FullName))
{
Writer.WriteObjectStart();
Writer.WriteValue("file", FileCommandPair.Key.FullName);
Writer.WriteValue("command", FileCommandPair.Value);
Writer.WriteValue("directory", UnrealBuildTool.EngineSourceDirectory.ToString());
Writer.WriteObjectEnd();
}
Writer.WriteArrayEnd();
}
}
return(0);
}
