CMake/Source/cmGlobalNinjaGenerator.h

419 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; }
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);
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
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;
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