CMake/Source/cmGlobalNinjaGenerator.h

436 lines
15 KiB
C
Raw Normal View History

2011-11-11 09:00:49 +04:00
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2011 Peter Collingbourne <peter@pcc.me.uk>
Copyright 2011 Nicolas Despres <nicolas.despres@gmail.com>
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#ifndef cmGlobalNinjaGenerator_h
#define cmGlobalNinjaGenerator_h
2011-11-11 09:00:49 +04:00
#include "cmGlobalCommonGenerator.h"
#include "cmGlobalGeneratorFactory.h"
#include "cmNinjaTypes.h"
2011-11-11 09:00:49 +04:00
//#define NINJA_GEN_VERBOSE_FILES
2011-11-11 09:00:49 +04:00
class cmLocalGenerator;
class cmGeneratedFileStream;
class cmGeneratorTarget;
2011-11-11 09:00:49 +04:00
/**
* \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 don't care about generating a clean target since Ninja already have
* a clean tool.
* - 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
2011-11-11 09:00:49 +04:00
{
public:
/// The default name of Ninja's build file. Typically: build.ninja.
static const char* NINJA_BUILD_FILE;
/// The default name of Ninja's rules file. Typically: rules.ninja.
/// It is included in the main build.ninja file.
static const char* NINJA_RULES_FILE;
/// The indentation string used when generating Ninja's build file.
static const char* INDENT;
/// 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);
static std::string EncodeIdent(const std::string& ident, std::ostream& vars);
static std::string EncodeLiteral(const std::string& lit);
std::string EncodePath(const std::string& path);
static std::string EncodeDepfileSpace(const std::string& path);
2011-11-11 09:00:49 +04:00
/**
* Write the given @a comment to the output stream @a os. It
* handles new line character properly.
*/
static void WriteComment(std::ostream& os, const std::string& 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; }
2011-11-11 09:00:49 +04:00
/**
* Write a build statement to @a os with the @a comment using
* the @a rule the list of @a outputs files and inputs.
* It also writes the variables bound to this build statement.
* @warning no escaping of any kind is done here.
*/
void WriteBuild(std::ostream& os, const std::string& comment,
const std::string& rule, const cmNinjaDeps& outputs,
const cmNinjaDeps& explicitDeps,
const cmNinjaDeps& implicitDeps,
const cmNinjaDeps& orderOnlyDeps,
const cmNinjaVars& variables,
const std::string& rspfile = std::string(),
2016-06-27 23:44:16 +03:00
int cmdLineLimit = 0, bool* usedResponseFile = CM_NULLPTR);
2011-11-11 09:00:49 +04:00
/**
* Helper to write a build statement with the special 'phony' rule.
*/
void WritePhonyBuild(std::ostream& os, const std::string& comment,
const cmNinjaDeps& outputs,
const cmNinjaDeps& explicitDeps,
const cmNinjaDeps& implicitDeps = cmNinjaDeps(),
const cmNinjaDeps& orderOnlyDeps = cmNinjaDeps(),
const cmNinjaVars& variables = cmNinjaVars());
2011-11-11 09:00:49 +04:00
void WriteCustomCommandBuild(const std::string& command,
const std::string& description,
const std::string& comment, bool uses_terminal,
bool restat, const cmNinjaDeps& outputs,
2011-11-11 09:00:49 +04:00
const cmNinjaDeps& deps = cmNinjaDeps(),
const cmNinjaDeps& orderOnly = cmNinjaDeps());
void WriteMacOSXContentBuild(const std::string& input,
const std::string& output);
2011-11-11 09:00:49 +04:00
/**
* Write a rule statement named @a name to @a os with the @a comment,
* the mandatory @a command, the @a depfile and the @a description.
* It also writes the variables bound to this rule statement.
* @warning no escaping of any kind is done here.
*/
static void WriteRule(std::ostream& os, const std::string& name,
2011-11-11 09:00:49 +04:00
const std::string& command,
const std::string& description,
const std::string& comment, const std::string& depfile,
const std::string& deptype, const std::string& rspfile,
const std::string& rspcontent,
const std::string& restat, bool generator);
2011-11-11 09:00:49 +04:00
/**
* 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, const std::string& name,
2011-11-11 09:00:49 +04:00
const std::string& value,
const std::string& comment = "", int indent = 0);
2011-11-11 09:00:49 +04:00
/**
* Write an include statement including @a filename with an optional
* @a comment to the @a os stream.
*/
static void WriteInclude(std::ostream& os, const std::string& filename,
2011-11-11 09:00:49 +04:00
const std::string& comment = "");
/**
* Write a default target statement specifying @a targets as
* the default targets.
*/
static void WriteDefault(std::ostream& os, const cmNinjaDeps& targets,
2011-11-11 09:00:49 +04:00
const std::string& comment = "");
bool IsGCCOnWindows() const { return UsingGCCOnWindows; }
2012-07-18 13:27:49 +04:00
2011-11-11 09:00:49 +04:00
public:
cmGlobalNinjaGenerator(cmake* cm);
2011-11-11 09:00:49 +04:00
static cmGlobalGeneratorFactory* NewFactory()
{
return new cmGlobalGeneratorSimpleFactory<cmGlobalNinjaGenerator>();
}
2011-11-11 09:00:49 +04:00
2016-06-27 22:25:27 +03:00
~cmGlobalNinjaGenerator() CM_OVERRIDE {}
2011-11-11 09:00:49 +04:00
2016-06-27 22:25:27 +03:00
cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf) CM_OVERRIDE;
2011-11-11 09:00:49 +04:00
2016-06-27 22:25:27 +03:00
std::string GetName() const CM_OVERRIDE
{
return cmGlobalNinjaGenerator::GetActualName();
}
2011-11-11 09:00:49 +04:00
static std::string GetActualName() { return "Ninja"; }
2011-11-11 09:00:49 +04:00
static void GetDocumentation(cmDocumentationEntry& entry);
2011-11-11 09:00:49 +04:00
2016-06-27 22:25:27 +03:00
void EnableLanguage(std::vector<std::string> const& languages,
cmMakefile* mf, bool optional) CM_OVERRIDE;
2011-11-11 09:00:49 +04:00
2016-06-27 22:25:27 +03:00
void GenerateBuildCommand(std::vector<std::string>& makeCommand,
const std::string& makeProgram,
const std::string& projectName,
const std::string& projectDir,
const std::string& targetName,
const std::string& config, bool fast, bool verbose,
std::vector<std::string> const& makeOptions =
std::vector<std::string>()) CM_OVERRIDE;
2011-11-11 09:00:49 +04:00
// Setup target names
2016-06-27 22:25:27 +03:00
const char* GetAllTargetName() const CM_OVERRIDE { return "all"; }
const char* GetInstallTargetName() const CM_OVERRIDE { return "install"; }
const char* GetInstallLocalTargetName() const CM_OVERRIDE
{
2011-11-11 09:00:49 +04:00
return "install/local";
}
2016-06-27 22:25:27 +03:00
const char* GetInstallStripTargetName() const CM_OVERRIDE
{
2011-11-11 09:00:49 +04:00
return "install/strip";
}
2016-06-27 22:25:27 +03:00
const char* GetTestTargetName() const CM_OVERRIDE { return "test"; }
const char* GetPackageTargetName() const CM_OVERRIDE { return "package"; }
const char* GetPackageSourceTargetName() const CM_OVERRIDE
{
2011-11-11 09:00:49 +04:00
return "package_source";
}
2016-06-27 22:25:27 +03:00
const char* GetEditCacheTargetName() const CM_OVERRIDE
{
return "edit_cache";
}
const char* GetRebuildCacheTargetName() const CM_OVERRIDE
{
2011-11-11 09:00:49 +04:00
return "rebuild_cache";
}
2016-06-27 22:25:27 +03:00
const char* GetCleanTargetName() const CM_OVERRIDE { return "clean"; }
2011-11-11 09:00:49 +04:00
cmGeneratedFileStream* GetBuildFileStream() const
{
return this->BuildFileStream;
}
2012-07-18 13:27:49 +04:00
cmGeneratedFileStream* GetRulesFileStream() const
{
return this->RulesFileStream;
}
2011-11-11 09:00:49 +04:00
std::string ConvertToNinjaPath(const std::string& path);
std::string ConvertToNinjaFolderRule(const std::string& path);
struct MapToNinjaPathImpl
{
cmGlobalNinjaGenerator* GG;
MapToNinjaPathImpl(cmGlobalNinjaGenerator* gg)
: GG(gg)
{
}
std::string operator()(std::string const& path)
{
return this->GG->ConvertToNinjaPath(path);
}
};
MapToNinjaPathImpl MapToNinjaPath() { return MapToNinjaPathImpl(this); }
void AddCXXCompileCommand(const std::string& commandLine,
const std::string& sourceFile);
2011-11-11 09:00:49 +04:00
/**
* 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(const std::string& name, const std::string& command,
const std::string& description, const std::string& comment,
const std::string& depfile, const std::string& deptype,
const std::string& rspfile, const std::string& rspcontent,
const std::string& restat, bool generator);
2011-11-11 09:00:49 +04:00
bool HasRule(const std::string& name);
void AddCustomCommandRule();
void AddMacOSXContentRule();
2011-11-11 09:00:49 +04:00
bool HasCustomCommandOutput(const std::string& output)
{
2012-07-18 13:27:49 +04:00
return this->CustomCommandOutputs.find(output) !=
this->CustomCommandOutputs.end();
2012-07-18 13:27:49 +04:00
}
/// Called when we have seen the given custom command. Returns true
/// if we has seen it before.
bool SeenCustomCommand(cmCustomCommand const* cc)
{
2012-07-18 13:27:49 +04:00
return !this->CustomCommands.insert(cc).second;
}
/// Called when we have seen the given custom command output.
void SeenCustomCommandOutput(const std::string& output)
{
2012-07-18 13:27:49 +04:00
this->CustomCommandOutputs.insert(output);
// We don't need the assumed dependencies anymore, because we have
// an output.
this->AssumedSourceDependencies.erase(output);
}
void AddAssumedSourceDependencies(const std::string& source,
const cmNinjaDeps& deps)
{
std::set<std::string>& ASD = this->AssumedSourceDependencies[source];
2012-07-18 13:27:49 +04:00
// 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());
}
2015-10-19 00:13:50 +03:00
void AppendTargetOutputs(cmGeneratorTarget const* target,
cmNinjaDeps& outputs);
void AppendTargetDepends(cmGeneratorTarget const* target,
cmNinjaDeps& outputs);
Ninja: Fix inter-target order-only dependencies of custom commands Custom command dependencies are followed for each target's source files and add their transitive closure to the corresponding target. This means that when a custom command in one target has a dependency on a custom command in another target, both will appear in the dependent target's sources. For the Makefile, VS IDE, and Xcode generators this is not a problem because each target gets its own independent build system that is evaluated in target dependency order. By the time the dependent target is built the custom command that belongs to one of its dependencies will already have been brought up to date. For the Ninja generator we need to generate a monolithic build system covering all targets so we can have only one copy of a custom command. This means that we need to reconcile the target-level ordering dependencies from its appearance in multiple targets to include only the least-dependent common set. This is done by computing the set intersection of the dependencies of all the targets containing a custom command. However, we previously included only the direct dependencies so any target-level dependency not directly added to all targets into which a custom command propagates was discarded. Fix this by computing the transitive closure of dependencies for each target and then intersecting those sets. That will get the common set of dependencies. Also add a test to cover a case in which the incorrectly dropped target ordering dependencies would fail.
2016-07-20 16:32:32 +03:00
void AppendTargetDependsClosure(cmGeneratorTarget const* target,
cmNinjaDeps& outputs);
2015-10-19 00:13:50 +03:00
void AddDependencyToAll(cmGeneratorTarget* target);
2012-07-18 13:27:49 +04:00
void AddDependencyToAll(const std::string& input);
const std::vector<cmLocalGenerator*>& GetLocalGenerators() const
{
return LocalGenerators;
}
2012-07-18 13:27:49 +04:00
bool IsExcluded(cmLocalGenerator* root, cmGeneratorTarget* target)
{
return cmGlobalGenerator::IsExcluded(root, target);
}
2012-07-18 13:27:49 +04:00
int GetRuleCmdLength(const std::string& name) { return RuleCmdLength[name]; }
2012-07-18 13:27:49 +04:00
2015-10-19 00:13:50 +03:00
void AddTargetAlias(const std::string& alias, cmGeneratorTarget* target);
2012-07-18 13:27:49 +04:00
2016-06-27 22:25:27 +03:00
void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const CM_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"; }
bool SupportsConsolePool() const;
std::string NinjaOutputPath(std::string const& path);
bool HasOutputPathPrefix() const { return !this->OutputPathPrefix.empty(); }
void StripNinjaOutputPathPrefixAsSuffix(std::string& path);
2011-11-11 09:00:49 +04:00
protected:
2016-06-27 22:25:27 +03:00
void Generate() CM_OVERRIDE;
2016-06-27 22:25:27 +03:00
bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const CM_OVERRIDE { return true; }
2011-11-11 09:00:49 +04:00
private:
2016-06-27 22:25:27 +03:00
std::string GetEditCacheCommand() const CM_OVERRIDE;
void FindMakeProgram(cmMakefile* mf) CM_OVERRIDE;
2011-11-11 09:00:49 +04:00
void OpenBuildFileStream();
void CloseBuildFileStream();
void CloseCompileCommandsStream();
2011-11-11 09:00:49 +04:00
void OpenRulesFileStream();
void CloseRulesFileStream();
/// Write the common disclaimer text at the top of each build file.
void WriteDisclaimer(std::ostream& os);
2012-02-05 05:48:08 +04:00
void WriteAssumedSourceDependencies();
2011-11-11 09:00:49 +04:00
void WriteTargetAliases(std::ostream& os);
void WriteFolderTargets(std::ostream& os);
void WriteUnknownExplicitDependencies(std::ostream& os);
2011-11-11 09:00:49 +04:00
void WriteBuiltinTargets(std::ostream& os);
void WriteTargetAll(std::ostream& os);
void WriteTargetRebuildManifest(std::ostream& os);
void WriteTargetClean(std::ostream& os);
2012-04-19 19:07:35 +04:00
void WriteTargetHelp(std::ostream& os);
2011-11-11 09:00:49 +04:00
Ninja: Fix inter-target order-only dependencies of custom commands Custom command dependencies are followed for each target's source files and add their transitive closure to the corresponding target. This means that when a custom command in one target has a dependency on a custom command in another target, both will appear in the dependent target's sources. For the Makefile, VS IDE, and Xcode generators this is not a problem because each target gets its own independent build system that is evaluated in target dependency order. By the time the dependent target is built the custom command that belongs to one of its dependencies will already have been brought up to date. For the Ninja generator we need to generate a monolithic build system covering all targets so we can have only one copy of a custom command. This means that we need to reconcile the target-level ordering dependencies from its appearance in multiple targets to include only the least-dependent common set. This is done by computing the set intersection of the dependencies of all the targets containing a custom command. However, we previously included only the direct dependencies so any target-level dependency not directly added to all targets into which a custom command propagates was discarded. Fix this by computing the transitive closure of dependencies for each target and then intersecting those sets. That will get the common set of dependencies. Also add a test to cover a case in which the incorrectly dropped target ordering dependencies would fail.
2016-07-20 16:32:32 +03:00
void ComputeTargetDependsClosure(
cmGeneratorTarget const* target,
std::set<cmGeneratorTarget const*>& depends);
2012-06-15 15:46:18 +04:00
std::string ninjaCmd() const;
2014-10-10 03:22:45 +04:00
/// The file containing the build statement. (the relationship of the
2011-11-11 09:00:49 +04:00
/// compilation DAG).
cmGeneratedFileStream* BuildFileStream;
/// The file containing the rule statements. (The action attached to each
/// edge of the compilation DAG).
cmGeneratedFileStream* RulesFileStream;
cmGeneratedFileStream* CompileCommandsStream;
2011-11-11 09:00:49 +04:00
/// The type used to store the set of rules added to the generated build
/// system.
typedef std::set<std::string> RulesSetType;
/// The set of rules added to the generated build system.
RulesSetType Rules;
/// Length of rule command, used by rsp file evaluation
std::map<std::string, int> RuleCmdLength;
2011-11-11 09:00:49 +04:00
/// The set of dependencies to add to the "all" target.
cmNinjaDeps AllDependencies;
bool UsingGCCOnWindows;
2011-11-11 09:00:49 +04:00
/// The set of custom commands we have seen.
std::set<cmCustomCommand const*> CustomCommands;
2011-11-11 09:00:49 +04:00
/// The set of custom command outputs we have seen.
std::set<std::string> CustomCommandOutputs;
/// Whether we are collecting known build outputs and needed
/// dependencies to determine unknown dependencies.
bool ComputingUnknownDependencies;
cmPolicies::PolicyStatus PolicyCMP0058;
/// The combined explicit dependencies of custom build commands
std::set<std::string> CombinedCustomCommandExplicitDependencies;
/// When combined with CombinedCustomCommandExplicitDependencies it allows
/// us to detect the set of explicit dependencies that have
std::set<std::string> CombinedBuildOutputs;
2011-11-11 09:00:49 +04:00
/// The mapping from source file to assumed dependencies.
std::map<std::string, std::set<std::string> > AssumedSourceDependencies;
2015-10-19 00:13:50 +03:00
typedef std::map<std::string, cmGeneratorTarget*> TargetAliasMap;
2011-11-11 09:00:49 +04:00
TargetAliasMap TargetAliases;
Ninja: Fix inter-target order-only dependencies of custom commands Custom command dependencies are followed for each target's source files and add their transitive closure to the corresponding target. This means that when a custom command in one target has a dependency on a custom command in another target, both will appear in the dependent target's sources. For the Makefile, VS IDE, and Xcode generators this is not a problem because each target gets its own independent build system that is evaluated in target dependency order. By the time the dependent target is built the custom command that belongs to one of its dependencies will already have been brought up to date. For the Ninja generator we need to generate a monolithic build system covering all targets so we can have only one copy of a custom command. This means that we need to reconcile the target-level ordering dependencies from its appearance in multiple targets to include only the least-dependent common set. This is done by computing the set intersection of the dependencies of all the targets containing a custom command. However, we previously included only the direct dependencies so any target-level dependency not directly added to all targets into which a custom command propagates was discarded. Fix this by computing the transitive closure of dependencies for each target and then intersecting those sets. That will get the common set of dependencies. Also add a test to cover a case in which the incorrectly dropped target ordering dependencies would fail.
2016-07-20 16:32:32 +03:00
typedef std::map<cmGeneratorTarget const*,
std::set<cmGeneratorTarget const*> >
TargetDependsClosureMap;
TargetDependsClosureMap TargetDependsClosures;
std::string NinjaCommand;
std::string NinjaVersion;
private:
void InitOutputPathPrefix();
std::string OutputPathPrefix;
std::string TargetAll;
std::string CMakeCacheFile;
2011-11-11 09:00:49 +04:00
};
#endif // ! cmGlobalNinjaGenerator_h