mirror of
https://gitlab.kitware.com/cmake/cmake.git
synced 2026-10-07 04:02:23 +03:00
Daniel Tierney
5898c8d2e0
C++ module importers may have specific usage requirements that differ from other importers of the same module, potentially requiring separate Built Module Interfaces (BMIs) for compatibility. CMake creates synthetic targets to generate and link usage-specific BMIs. This change extends CMake's per-importer BMI generation to native targets in addition to imported targets.
756 lines
25 KiB
C++
756 lines
25 KiB
C++
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file LICENSE.rst or https://cmake.org/licensing for details. */
|
|
#pragma once
|
|
|
|
#include "cmConfigure.h" // IWYU pragma: keep
|
|
|
|
#include <iosfwd>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <set>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <cm/optional>
|
|
|
|
#include "cm_codecvt_Encoding.hxx"
|
|
|
|
#include "cmBuildOptions.h"
|
|
#include "cmGeneratedFileStream.h"
|
|
#include "cmGlobalCommonGenerator.h"
|
|
#include "cmGlobalGeneratorFactory.h"
|
|
#include "cmNinjaTypes.h"
|
|
#include "cmStringAlgorithms.h"
|
|
#include "cmTransformDepfile.h"
|
|
|
|
class cmCustomCommand;
|
|
class cmGeneratorTarget;
|
|
class cmMakefile;
|
|
class cmake;
|
|
struct cmCxxModuleExportInfo;
|
|
|
|
/**
|
|
* \class cmGlobalNinjaGenerator
|
|
* \brief Write a build.ninja file.
|
|
*
|
|
* The main differences between this generator and the UnixMakefile
|
|
* generator family are:
|
|
* - We don't care about VERBOSE variable or RULE_MESSAGES property since
|
|
* it is handle by Ninja's -v option.
|
|
* - We don't care about computing any progress status since Ninja manages
|
|
* it itself.
|
|
* - We generate one build.ninja and one rules.ninja per project.
|
|
* - We try to minimize the number of generated rules: one per target and
|
|
* language.
|
|
* - We use Ninja special variable $in and $out to produce nice output.
|
|
* - We extensively use Ninja variable overloading system to minimize the
|
|
* number of generated rules.
|
|
*/
|
|
class cmGlobalNinjaGenerator : public cmGlobalCommonGenerator
|
|
{
|
|
public:
|
|
/// The default name of Ninja's build file. Typically: build.ninja.
|
|
static char const* NINJA_BUILD_FILE;
|
|
|
|
/// The default name of Ninja's rules file. Typically: rules.ninja.
|
|
/// It is included in the main build.ninja file.
|
|
static char const* NINJA_RULES_FILE;
|
|
|
|
/// The indentation string used when generating Ninja's build file.
|
|
static char const* INDENT;
|
|
|
|
/// The shell command used for a no-op.
|
|
static std::string const SHELL_NOOP;
|
|
|
|
/// Write @a count times INDENT level to output stream @a os.
|
|
static void Indent(std::ostream& os, int count);
|
|
|
|
/// Write a divider in the given output stream @a os.
|
|
static void WriteDivider(std::ostream& os);
|
|
|
|
static std::string EncodeRuleName(std::string const& name);
|
|
std::string& EncodeLiteral(std::string& lit) override;
|
|
std::string EncodePath(std::string const& path);
|
|
|
|
std::unique_ptr<cmLinkLineComputer> CreateLinkLineComputer(
|
|
cmOutputConverter* outputConverter,
|
|
cmStateDirectory const& stateDir) const override;
|
|
|
|
/**
|
|
* Write the given @a comment to the output stream @a os. It
|
|
* handles new line character properly.
|
|
*/
|
|
static void WriteComment(std::ostream& os, std::string const& comment);
|
|
|
|
/**
|
|
* Utilized by the generator factory to determine if this generator
|
|
* supports toolsets.
|
|
*/
|
|
static bool SupportsToolset() { return false; }
|
|
|
|
/**
|
|
* Utilized by the generator factory to determine if this generator
|
|
* supports platforms.
|
|
*/
|
|
static bool SupportsPlatform() { return false; }
|
|
|
|
bool IsIPOSupported() const override { return true; }
|
|
|
|
/**
|
|
* Write a build statement @a build to @a os.
|
|
* @warning no escaping of any kind is done here.
|
|
*/
|
|
void WriteBuild(std::ostream& os, cmNinjaBuild const& build,
|
|
int cmdLineLimit = 0, bool* usedResponseFile = nullptr);
|
|
|
|
class CCOutputs
|
|
{
|
|
cmGlobalNinjaGenerator* GG;
|
|
|
|
public:
|
|
CCOutputs(cmGlobalNinjaGenerator* gg)
|
|
: GG(gg)
|
|
{
|
|
}
|
|
void Add(std::vector<std::string> const& outputs);
|
|
cmNinjaDeps ExplicitOuts;
|
|
cmNinjaDeps WorkDirOuts;
|
|
};
|
|
|
|
void WriteCustomCommandBuild(std::string const& command,
|
|
std::string const& description,
|
|
std::string const& comment,
|
|
std::string const& depfile,
|
|
std::string const& pool, bool uses_terminal,
|
|
bool restat, std::string const& config,
|
|
CCOutputs outputs,
|
|
cmNinjaDeps explicitDeps = cmNinjaDeps(),
|
|
cmNinjaDeps orderOnlyDeps = cmNinjaDeps());
|
|
|
|
void WriteMacOSXContentBuild(std::string input, std::string output,
|
|
std::string const& config);
|
|
|
|
/**
|
|
* Write a rule statement to @a os.
|
|
* @warning no escaping of any kind is done here.
|
|
*/
|
|
static void WriteRule(std::ostream& os, cmNinjaRule const& rule);
|
|
|
|
/**
|
|
* Write a variable named @a name to @a os with value @a value and an
|
|
* optional @a comment. An @a indent level can be specified.
|
|
* @warning no escaping of any kind is done here.
|
|
*/
|
|
static void WriteVariable(std::ostream& os, std::string const& name,
|
|
std::string const& value,
|
|
std::string const& comment = "", int indent = 0);
|
|
|
|
/**
|
|
* Write an include statement including @a filename with an optional
|
|
* @a comment to the @a os stream.
|
|
*/
|
|
static void WriteInclude(std::ostream& os, std::string const& filename,
|
|
std::string const& comment = "");
|
|
|
|
/**
|
|
* Write a default target statement specifying @a targets as
|
|
* the default targets.
|
|
*/
|
|
static void WriteDefault(std::ostream& os, cmNinjaDeps const& targets,
|
|
std::string const& comment = "");
|
|
|
|
bool IsGCCOnWindows() const { return this->UsingGCCOnWindows; }
|
|
void MarkAsGCCOnWindows() { this->UsingGCCOnWindows = true; }
|
|
|
|
cmGlobalNinjaGenerator(cmake* cm);
|
|
|
|
static std::unique_ptr<cmGlobalGeneratorFactory> NewFactory()
|
|
{
|
|
return std::unique_ptr<cmGlobalGeneratorFactory>(
|
|
new cmGlobalGeneratorSimpleFactory<cmGlobalNinjaGenerator>());
|
|
}
|
|
|
|
std::unique_ptr<cmLocalGenerator> CreateLocalGenerator(
|
|
cmMakefile* mf) override;
|
|
|
|
std::string GetName() const override
|
|
{
|
|
return cmGlobalNinjaGenerator::GetActualName();
|
|
}
|
|
|
|
static std::string GetActualName() { return "Ninja"; }
|
|
|
|
bool IsNinja() const override { return true; }
|
|
|
|
/** Get encoding used by generator for ninja files */
|
|
codecvt_Encoding GetMakefileEncoding() const override;
|
|
|
|
static cmDocumentationEntry GetDocumentation();
|
|
|
|
void EnableLanguage(std::vector<std::string> const& languages,
|
|
cmMakefile* mf, bool optional) override;
|
|
|
|
std::vector<GeneratedMakeCommand> GenerateBuildCommand(
|
|
std::string const& makeProgram, std::string const& projectName,
|
|
std::string const& projectDir, std::vector<std::string> const& targetNames,
|
|
std::string const& config, int jobs, bool verbose,
|
|
cmBuildOptions buildOptions = cmBuildOptions(),
|
|
std::vector<std::string> const& makeOptions = std::vector<std::string>(),
|
|
BuildTryCompile isInTryCompile = BuildTryCompile::No) override;
|
|
|
|
// Setup target names
|
|
char const* GetAllTargetName() const override { return "all"; }
|
|
char const* GetInstallTargetName() const override { return "install"; }
|
|
char const* GetInstallLocalTargetName() const override
|
|
{
|
|
return "install/local";
|
|
}
|
|
char const* GetInstallStripTargetName() const override
|
|
{
|
|
return "install/strip";
|
|
}
|
|
char const* GetInstallParallelTargetName() const
|
|
{
|
|
return "install/parallel";
|
|
}
|
|
char const* GetTestTargetName() const override { return "test"; }
|
|
char const* GetPackageTargetName() const override { return "package"; }
|
|
char const* GetPackageSourceTargetName() const override
|
|
{
|
|
return "package_source";
|
|
}
|
|
char const* GetRebuildCacheTargetName() const override
|
|
{
|
|
return "rebuild_cache";
|
|
}
|
|
char const* GetCleanTargetName() const override { return "clean"; }
|
|
|
|
bool SupportsCustomCommandDepfile() const override { return true; }
|
|
cm::optional<cmDepfileFormat> DepfileFormat() const override
|
|
{
|
|
return cmDepfileFormat::GccDepfile;
|
|
}
|
|
|
|
bool SupportsLinkerDependencyFile() const override { return true; }
|
|
|
|
virtual cmGeneratedFileStream* GetImplFileStream(
|
|
std::string const& /*config*/) const
|
|
{
|
|
return this->BuildFileStream.get();
|
|
}
|
|
|
|
virtual cmGeneratedFileStream* GetConfigFileStream(
|
|
std::string const& /*config*/) const
|
|
{
|
|
return this->BuildFileStream.get();
|
|
}
|
|
|
|
virtual cmGeneratedFileStream* GetDefaultFileStream() const
|
|
{
|
|
return this->BuildFileStream.get();
|
|
}
|
|
|
|
virtual cmGeneratedFileStream* GetCommonFileStream() const
|
|
{
|
|
return this->BuildFileStream.get();
|
|
}
|
|
|
|
cmGeneratedFileStream* GetRulesFileStream() const
|
|
{
|
|
return this->RulesFileStream.get();
|
|
}
|
|
|
|
std::string const& ConvertToNinjaPath(std::string const& path) const;
|
|
std::string ConvertToNinjaAbsPath(std::string path) const;
|
|
|
|
struct MapToNinjaPathImpl
|
|
{
|
|
cmGlobalNinjaGenerator* GG;
|
|
MapToNinjaPathImpl(cmGlobalNinjaGenerator* gg)
|
|
: GG(gg)
|
|
{
|
|
}
|
|
std::string operator()(std::string const& path) const
|
|
{
|
|
return this->GG->ConvertToNinjaPath(path);
|
|
}
|
|
};
|
|
MapToNinjaPathImpl MapToNinjaPath() { return { this }; }
|
|
|
|
#ifdef _WIN32
|
|
std::string const& GetComspec() const { return this->Comspec; }
|
|
#endif
|
|
|
|
// -- Additional clean files
|
|
void AddAdditionalCleanFile(std::string fileName, std::string const& config);
|
|
char const* GetAdditionalCleanTargetName() const
|
|
{
|
|
return "CMakeFiles/clean.additional";
|
|
}
|
|
|
|
static char const* GetByproductsForCleanTargetName()
|
|
{
|
|
return "CMakeFiles/cmake_byproducts_for_clean_target";
|
|
}
|
|
|
|
void AddCXXCompileCommand(std::string const& commandLine,
|
|
std::string const& sourceFile,
|
|
std::string const& objPath);
|
|
|
|
/**
|
|
* Add a rule to the generated build system.
|
|
* Call WriteRule() behind the scene but perform some check before like:
|
|
* - Do not add twice the same rule.
|
|
*/
|
|
void AddRule(cmNinjaRule const& rule);
|
|
|
|
bool HasRule(std::string const& name);
|
|
|
|
void AddCustomCommandRule();
|
|
void AddMacOSXContentRule();
|
|
|
|
bool HasCustomCommandOutput(std::string const& output)
|
|
{
|
|
return this->CustomCommandOutputs.find(output) !=
|
|
this->CustomCommandOutputs.end();
|
|
}
|
|
|
|
/// Called when we have seen the given custom command. Returns true
|
|
/// if we has seen it before.
|
|
bool SeenCustomCommand(cmCustomCommand const* cc, std::string const& config)
|
|
{
|
|
return !this->Configs[config].CustomCommands.insert(cc).second;
|
|
}
|
|
|
|
/// Called when we have seen the given custom command output.
|
|
void SeenCustomCommandOutput(std::string const& output)
|
|
{
|
|
this->CustomCommandOutputs.insert(output);
|
|
// We don't need the assumed dependencies anymore, because we have
|
|
// an output.
|
|
this->AssumedSourceDependencies.erase(output);
|
|
}
|
|
|
|
void AddAssumedSourceDependencies(std::string const& source,
|
|
cmNinjaDeps const& deps)
|
|
{
|
|
std::set<std::string>& ASD = this->AssumedSourceDependencies[source];
|
|
// Because we may see the same source file multiple times (same source
|
|
// specified in multiple targets), compute the union of any assumed
|
|
// dependencies.
|
|
ASD.insert(deps.begin(), deps.end());
|
|
}
|
|
|
|
virtual std::string OrderDependsTargetForTarget(
|
|
cmGeneratorTarget const* target, std::string const& config) const;
|
|
|
|
std::string OrderDependsTargetForTargetPrivate(
|
|
cmGeneratorTarget const* target, std::string const& config) const;
|
|
|
|
void AppendTargetOutputs(cmGeneratorTarget const* target,
|
|
cmNinjaDeps& outputs, std::string const& config,
|
|
cmNinjaTargetDepends depends) const;
|
|
void AppendTargetDepends(cmGeneratorTarget const* target,
|
|
cmNinjaDeps& outputs, std::string const& config,
|
|
std::string const& fileConfig,
|
|
cmNinjaTargetDepends depends);
|
|
void AppendTargetDependsClosure(cmGeneratorTarget const* target,
|
|
std::unordered_set<std::string>& outputs,
|
|
std::string const& config,
|
|
std::string const& fileConfig,
|
|
bool genexOutput, bool omit_self = true);
|
|
|
|
void AppendDirectoryForConfig(std::string const& prefix,
|
|
std::string const& config,
|
|
std::string const& suffix,
|
|
std::string& dir) override;
|
|
|
|
virtual void AppendNinjaFileArgument(GeneratedMakeCommand& /*command*/,
|
|
std::string const& /*config*/) const
|
|
{
|
|
}
|
|
|
|
virtual void AddRebuildManifestOutputs(cmNinjaDeps& outputs) const
|
|
{
|
|
outputs.push_back(this->NinjaOutputPath(NINJA_BUILD_FILE));
|
|
this->AddCMakeFilesToRebuild(outputs);
|
|
}
|
|
|
|
int GetRuleCmdLength(std::string const& name)
|
|
{
|
|
return this->RuleCmdLength[name];
|
|
}
|
|
|
|
void AddTargetAlias(std::string const& alias, cmGeneratorTarget* target,
|
|
std::string const& config);
|
|
|
|
bool SupportsShortObjectNames() const override;
|
|
void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const override;
|
|
|
|
// Ninja generator uses 'deps' and 'msvc_deps_prefix' introduced in 1.3
|
|
static std::string RequiredNinjaVersion() { return "1.3"; }
|
|
static std::string RequiredNinjaVersionForConsolePool() { return "1.5"; }
|
|
static std::string RequiredNinjaVersionForImplicitOuts() { return "1.7"; }
|
|
static std::string RequiredNinjaVersionForManifestRestat() { return "1.8"; }
|
|
static std::string RequiredNinjaVersionForMultilineDepfile()
|
|
{
|
|
return "1.9";
|
|
}
|
|
static std::string RequiredNinjaVersionForDyndepsCxx() { return "1.11"; }
|
|
static std::string RequiredNinjaVersionForDyndepsFortran() { return "1.10"; }
|
|
static std::string RequiredNinjaVersionForRestatTool() { return "1.10"; }
|
|
static std::string RequiredNinjaVersionForUnconditionalRecompactTool()
|
|
{
|
|
return "1.10";
|
|
}
|
|
static std::string RequiredNinjaVersionForMultipleOutputs()
|
|
{
|
|
return "1.10";
|
|
}
|
|
static std::string RequiredNinjaVersionForMetadataOnRegeneration()
|
|
{
|
|
return "1.10.2";
|
|
}
|
|
static std::string RequiredNinjaVersionForCodePage() { return "1.11"; }
|
|
static std::string RequiredNinjaVersionForCWDDepend() { return "1.7"; }
|
|
bool SupportsDirectConsole() const override;
|
|
bool SupportsImplicitOuts() const;
|
|
bool SupportsManifestRestat() const;
|
|
bool SupportsMultilineDepfile() const;
|
|
bool SupportsCWDDepend() const;
|
|
|
|
std::string NinjaOutputPath(std::string const& path) const;
|
|
bool HasOutputPathPrefix() const { return !this->OutputPathPrefix.empty(); }
|
|
void StripNinjaOutputPathPrefixAsSuffix(std::string& path);
|
|
|
|
bool WriteDyndepFile(
|
|
std::string const& dir_top_src, std::string const& dir_top_bld,
|
|
std::string const& dir_cur_src, std::string const& dir_cur_bld,
|
|
std::string const& arg_dd, std::vector<std::string> const& arg_ddis,
|
|
std::string const& module_dir,
|
|
std::vector<std::string> const& linked_target_dirs,
|
|
std::vector<std::string> const& forward_modules_from_target_dirs,
|
|
std::string const& native_target_dir, std::string const& arg_lang,
|
|
std::string const& arg_modmapfmt,
|
|
cmCxxModuleExportInfo const& export_info);
|
|
|
|
virtual std::string BuildAlias(std::string const& alias,
|
|
std::string const& /*config*/) const
|
|
{
|
|
return alias;
|
|
}
|
|
|
|
virtual std::string ConfigDirectory(std::string const& /*config*/) const
|
|
{
|
|
return "";
|
|
}
|
|
|
|
cmNinjaDeps& GetByproductsForCleanTarget()
|
|
{
|
|
return this->ByproductsForCleanTarget;
|
|
}
|
|
|
|
cmNinjaDeps& GetByproductsForCleanTarget(std::string const& config)
|
|
{
|
|
return this->Configs[config].ByproductsForCleanTarget;
|
|
}
|
|
|
|
bool EnableCrossConfigBuild() const;
|
|
|
|
std::set<std::string> GetCrossConfigs(std::string const& config) const;
|
|
|
|
std::set<std::string> const& GetDefaultConfigs() const override
|
|
{
|
|
return this->DefaultConfigs;
|
|
}
|
|
|
|
std::set<std::string> const& GetPerConfigUtilityTargets() const
|
|
{
|
|
return this->PerConfigUtilityTargets;
|
|
}
|
|
|
|
void AddPerConfigUtilityTarget(std::string const& name)
|
|
{
|
|
this->PerConfigUtilityTargets.insert(name);
|
|
}
|
|
|
|
bool IsSingleConfigUtility(cmGeneratorTarget const* target) const;
|
|
|
|
bool CheckCxxModuleSupport(CxxModuleSupportQuery query) override;
|
|
bool SupportsBuildDatabase() const override { return true; }
|
|
|
|
std::string ConvertToOutputPath(std::string path) const override;
|
|
|
|
protected:
|
|
std::vector<std::string> const& GetConfigNames() const;
|
|
|
|
void Generate() override;
|
|
|
|
bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const override { return true; }
|
|
|
|
virtual bool OpenBuildFileStreams();
|
|
virtual void CloseBuildFileStreams();
|
|
|
|
bool OpenFileStream(std::unique_ptr<cmGeneratedFileStream>& stream,
|
|
std::string const& name);
|
|
|
|
static cm::optional<std::set<std::string>> ListSubsetWithAll(
|
|
std::set<std::string> const& all, std::set<std::string> const& defaults,
|
|
std::vector<std::string> const& items);
|
|
|
|
std::set<std::string> CrossConfigs;
|
|
std::set<std::string> DefaultConfigs;
|
|
std::string DefaultFileConfig;
|
|
|
|
private:
|
|
bool FindMakeProgram(cmMakefile* mf) override;
|
|
void CheckNinjaFeatures();
|
|
void CheckNinjaCodePage();
|
|
bool CheckLanguages(std::vector<std::string> const& languages,
|
|
cmMakefile* mf) const override;
|
|
bool CheckFortran(cmMakefile* mf) const;
|
|
bool CheckISPC(cmMakefile* mf) const;
|
|
|
|
void CloseCompileCommandsStream();
|
|
|
|
bool OpenRulesFileStream();
|
|
void CloseRulesFileStream();
|
|
void CleanMetaData();
|
|
|
|
/// Write the common disclaimer text at the top of each build file.
|
|
void WriteDisclaimer(std::ostream& os) const;
|
|
|
|
void WriteAssumedSourceDependencies();
|
|
|
|
void WriteTargetAliases(std::ostream& os);
|
|
void WriteFolderTargets(std::ostream& os);
|
|
|
|
void WriteBuiltinTargets(std::ostream& os);
|
|
void WriteTargetDefault(std::ostream& os);
|
|
void WriteTargetRebuildManifest(std::ostream& os);
|
|
bool WriteTargetCleanAdditional(std::ostream& os);
|
|
void WriteTargetClean(std::ostream& os);
|
|
#ifndef CMAKE_BOOTSTRAP
|
|
void WriteTargetInstrument(std::ostream& os);
|
|
#endif
|
|
void WriteTargetHelp(std::ostream& os);
|
|
|
|
void ComputeTargetDependsClosure(
|
|
cmGeneratorTarget const* target,
|
|
std::set<cmGeneratorTarget const*>& depends);
|
|
|
|
std::string CMakeCmd() const;
|
|
std::string NinjaCmd() const;
|
|
|
|
/// The file containing the build statement. (the relationship of the
|
|
/// compilation DAG).
|
|
std::unique_ptr<cmGeneratedFileStream> BuildFileStream;
|
|
/// The file containing the rule statements. (The action attached to each
|
|
/// edge of the compilation DAG).
|
|
std::unique_ptr<cmGeneratedFileStream> RulesFileStream;
|
|
std::unique_ptr<cmGeneratedFileStream> CompileCommandsStream;
|
|
|
|
/// The set of rules added to the generated build system.
|
|
std::unordered_set<std::string> Rules;
|
|
|
|
/// Length of rule command, used by rsp file evaluation
|
|
std::unordered_map<std::string, int> RuleCmdLength;
|
|
|
|
bool UsingGCCOnWindows = false;
|
|
|
|
/// The set of custom command outputs we have seen.
|
|
std::set<std::string> CustomCommandOutputs;
|
|
|
|
/// The mapping from source file to assumed dependencies.
|
|
std::map<std::string, std::set<std::string>> AssumedSourceDependencies;
|
|
|
|
/// Utility targets which have per-config outputs
|
|
std::set<std::string> PerConfigUtilityTargets;
|
|
|
|
struct TargetAlias
|
|
{
|
|
cmGeneratorTarget* GeneratorTarget;
|
|
std::string Config;
|
|
};
|
|
using TargetAliasMap = std::map<std::string, TargetAlias>;
|
|
TargetAliasMap TargetAliases;
|
|
TargetAliasMap DefaultTargetAliases;
|
|
|
|
/// the local cache for calls to ConvertToNinjaPath
|
|
mutable std::unordered_map<std::string, std::string> ConvertToNinjaPathCache;
|
|
|
|
std::string NinjaCommand;
|
|
std::string NinjaVersion;
|
|
bool NinjaSupportsConsolePool = false;
|
|
bool NinjaSupportsImplicitOuts = false;
|
|
bool NinjaSupportsManifestRestat = false;
|
|
bool NinjaSupportsMultilineDepfile = false;
|
|
bool NinjaSupportsDyndepsCxx = false;
|
|
bool NinjaSupportsDyndepsFortran = false;
|
|
bool NinjaSupportsRestatTool = false;
|
|
bool NinjaSupportsUnconditionalRecompactTool = false;
|
|
bool NinjaSupportsMultipleOutputs = false;
|
|
bool NinjaSupportsMetadataOnRegeneration = false;
|
|
bool NinjaSupportsCodePage = false;
|
|
bool NinjaSupportsCWDDepend = false;
|
|
|
|
codecvt_Encoding NinjaExpectedEncoding = codecvt_Encoding::None;
|
|
|
|
#ifdef _WIN32
|
|
// Windows Command shell.
|
|
std::string Comspec;
|
|
#endif
|
|
|
|
bool DiagnosedCxxModuleNinjaSupport = false;
|
|
|
|
void InitOutputPathPrefix();
|
|
|
|
std::string OutputPathPrefix;
|
|
std::string TargetAll;
|
|
std::string CMakeCacheFile;
|
|
|
|
struct ByConfig
|
|
{
|
|
std::set<std::string> AdditionalCleanFiles;
|
|
|
|
/// The set of custom commands we have seen.
|
|
std::set<cmCustomCommand const*> CustomCommands;
|
|
|
|
struct TargetDependsClosureKey
|
|
{
|
|
cmGeneratorTarget const* Target;
|
|
std::string Config;
|
|
bool GenexOutput;
|
|
};
|
|
|
|
std::map<TargetDependsClosureKey, std::unordered_set<std::string>>
|
|
TargetDependsClosures;
|
|
|
|
TargetAliasMap TargetAliases;
|
|
|
|
cmNinjaDeps ByproductsForCleanTarget;
|
|
};
|
|
std::map<std::string, ByConfig> Configs;
|
|
|
|
cmNinjaDeps ByproductsForCleanTarget;
|
|
|
|
friend bool operator==(ByConfig::TargetDependsClosureKey const& lhs,
|
|
ByConfig::TargetDependsClosureKey const& rhs);
|
|
friend bool operator!=(ByConfig::TargetDependsClosureKey const& lhs,
|
|
ByConfig::TargetDependsClosureKey const& rhs);
|
|
friend bool operator<(ByConfig::TargetDependsClosureKey const& lhs,
|
|
ByConfig::TargetDependsClosureKey const& rhs);
|
|
friend bool operator>(ByConfig::TargetDependsClosureKey const& lhs,
|
|
ByConfig::TargetDependsClosureKey const& rhs);
|
|
friend bool operator<=(ByConfig::TargetDependsClosureKey const& lhs,
|
|
ByConfig::TargetDependsClosureKey const& rhs);
|
|
friend bool operator>=(ByConfig::TargetDependsClosureKey const& lhs,
|
|
ByConfig::TargetDependsClosureKey const& rhs);
|
|
};
|
|
|
|
class cmGlobalNinjaMultiGenerator : public cmGlobalNinjaGenerator
|
|
{
|
|
public:
|
|
/// The default name of Ninja's common file. Typically: common.ninja.
|
|
static char const* NINJA_COMMON_FILE;
|
|
/// The default file extension to use for per-config Ninja files.
|
|
static char const* NINJA_FILE_EXTENSION;
|
|
|
|
cmGlobalNinjaMultiGenerator(cmake* cm);
|
|
bool IsMultiConfig() const override { return true; }
|
|
static std::unique_ptr<cmGlobalGeneratorFactory> NewFactory()
|
|
{
|
|
return std::unique_ptr<cmGlobalGeneratorFactory>(
|
|
new cmGlobalGeneratorSimpleFactory<cmGlobalNinjaMultiGenerator>());
|
|
}
|
|
|
|
static cmDocumentationEntry GetDocumentation();
|
|
|
|
std::string GetName() const override
|
|
{
|
|
return cmGlobalNinjaMultiGenerator::GetActualName();
|
|
}
|
|
|
|
static std::string GetActualName() { return "Ninja Multi-Config"; }
|
|
|
|
std::string BuildAlias(std::string const& alias,
|
|
std::string const& config) const override
|
|
{
|
|
if (config.empty()) {
|
|
return alias;
|
|
}
|
|
return cmStrCat(alias, ":", config);
|
|
}
|
|
|
|
std::string ConfigDirectory(std::string const& config) const override
|
|
{
|
|
if (!config.empty()) {
|
|
return cmStrCat('/', config);
|
|
}
|
|
return "";
|
|
}
|
|
|
|
char const* GetCMakeCFGIntDir() const override { return "${CONFIGURATION}"; }
|
|
|
|
std::string ExpandCFGIntDir(std::string const& str,
|
|
std::string const& config) const override;
|
|
|
|
cmGeneratedFileStream* GetImplFileStream(
|
|
std::string const& config) const override
|
|
{
|
|
return this->ImplFileStreams.at(config).get();
|
|
}
|
|
|
|
cmGeneratedFileStream* GetConfigFileStream(
|
|
std::string const& config) const override
|
|
{
|
|
return this->ConfigFileStreams.at(config).get();
|
|
}
|
|
|
|
cmGeneratedFileStream* GetDefaultFileStream() const override
|
|
{
|
|
return this->DefaultFileStream.get();
|
|
}
|
|
|
|
cmGeneratedFileStream* GetCommonFileStream() const override
|
|
{
|
|
return this->CommonFileStream.get();
|
|
}
|
|
|
|
void AppendNinjaFileArgument(GeneratedMakeCommand& command,
|
|
std::string const& config) const override;
|
|
|
|
static std::string GetNinjaImplFilename(std::string const& config);
|
|
static std::string GetNinjaConfigFilename(std::string const& config);
|
|
|
|
void AddRebuildManifestOutputs(cmNinjaDeps& outputs) const override;
|
|
|
|
void GetQtAutoGenConfigs(std::vector<std::string>& configs) const override;
|
|
|
|
bool InspectConfigTypeVariables() override;
|
|
|
|
std::string GetDefaultBuildConfig() const override;
|
|
|
|
bool SupportsDefaultBuildType() const override { return true; }
|
|
bool SupportsCrossConfigs() const override { return true; }
|
|
bool SupportsDefaultConfigs() const override { return true; }
|
|
|
|
std::string OrderDependsTargetForTarget(
|
|
cmGeneratorTarget const* target, std::string const& config) const override;
|
|
|
|
protected:
|
|
bool OpenBuildFileStreams() override;
|
|
void CloseBuildFileStreams() override;
|
|
|
|
private:
|
|
std::map<std::string, std::unique_ptr<cmGeneratedFileStream>>
|
|
ImplFileStreams;
|
|
std::map<std::string, std::unique_ptr<cmGeneratedFileStream>>
|
|
ConfigFileStreams;
|
|
std::unique_ptr<cmGeneratedFileStream> CommonFileStream;
|
|
std::unique_ptr<cmGeneratedFileStream> DefaultFileStream;
|
|
};
|