reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-12-14 07:09:22 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
3837c48334
CMake/Source/cmGlobalNinjaGenerator.cxx

1293 lines
40 KiB
C++
Raw Normal View History

Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00: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.
============================================================================*/
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
#include "cmGeneratedFileStream.h"
#include "cmGeneratorExpressionEvaluationFile.h"
#include "cmGeneratorTarget.h"
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
#include "cmGlobalNinjaGenerator.h"
#include "cmLocalNinjaGenerator.h"
#include "cmMakefile.h"
#include "cmVersion.h"
Ninja: Add policy to require explicit custom command byproducts Add policy CMP0058 to avoid generating 'phony' ninja rules for unknown custom command dependencies. This requires projects to specify their custom command byproducts explicitly. With this requirement we no longer have to assume that unknown custom command dependencies are generated and can instead simply assume they are source files expected to exist when the build starts. This is particularly important in in-source builds. It is also helpful for out-of-source builds to allow Ninja to diagnose missing files before running custom command rules that depend on them.
2015-03-20 20:43:21 +00:00
#include "cmAlgorithms.h"
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
Ninja: the Ninja generator does not support Fortran yet.
2013-03-10 10:36:57 +00:00
#include <algorithm>
cmLocalGenerator: Add ComputeObjectFilenames interface. Implement it in the local generators and use it in the global generators.
2014-03-11 16:37:26 +00:00
#include <assert.h>
Ninja: the Ninja generator does not support Fortran yet.
2013-03-10 10:36:57 +00:00
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
const char* cmGlobalNinjaGenerator::NINJA_BUILD_FILE = "build.ninja";
const char* cmGlobalNinjaGenerator::NINJA_RULES_FILE = "rules.ninja";
const char* cmGlobalNinjaGenerator::INDENT = " ";
void cmGlobalNinjaGenerator::Indent(std::ostream& os, int count)
{
for(int i = 0; i < count; ++i)
os << cmGlobalNinjaGenerator::INDENT;
}
void cmGlobalNinjaGenerator::WriteDivider(std::ostream& os)
{
os
<< "# ======================================"
<< "=======================================\n";
}
void cmGlobalNinjaGenerator::WriteComment(std::ostream& os,
const std::string& comment)
{
if (comment.empty())
return;
std::string replace = comment;
std::string::size_type lpos = 0;
std::string::size_type rpos;
Ninja: don't pollute the rules file with useless comments
2012-06-10 18:20:29 +00:00
os << "\n#############################################\n";
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
while((rpos = replace.find('\n', lpos)) != std::string::npos)
{
os << "# " << replace.substr(lpos, rpos - lpos) << "\n";
lpos = rpos + 1;
}
Ninja: don't pollute the rules file with useless comments
2012-06-10 18:20:29 +00:00
os << "# " << replace.substr(lpos) << "\n\n";
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
static bool IsIdentChar(char c)
{
return
('a' <= c && c <= 'z') ||
('+' <= c && c <= '9') || // +,-./ and numbers
('A' <= c && c <= 'Z') ||
Ninja: Identifier encoding rules for ' ' and ':'
2012-02-18 19:04:55 +00:00
(c == '_') || (c == '$') || (c == '\\') ||
(c == ' ') || (c == ':');
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
std::string cmGlobalNinjaGenerator::EncodeIdent(const std::string &ident,
std::ostream &vars) {
if (std::find_if(ident.begin(), ident.end(),
std::not1(std::ptr_fun(IsIdentChar))) != ident.end()) {
static unsigned VarNum = 0;
Port all cmOStringStream to std::ostringstream. All compilers hosting CMake support the std class.
2015-01-05 19:31:31 +00:00
std::ostringstream names;
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
names << "ident" << VarNum++;
vars << names.str() << " = " << ident << "\n";
return "$" + names.str();
} else {
Ninja: Identifier encoding rules for ' ' and ':'
2012-02-18 19:04:55 +00:00
std::string result = ident;
cmSystemTools::ReplaceString(result, " ", "$ ");
cmSystemTools::ReplaceString(result, ":", "$:");
return result;
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
}
std::string cmGlobalNinjaGenerator::EncodeLiteral(const std::string &lit)
{
std::string result = lit;
cmSystemTools::ReplaceString(result, "$", "$$");
Ninja: escape line breaks in literals BUG: 13591
2013-03-09 11:04:16 +00:00
cmSystemTools::ReplaceString(result, "\n", "$\n");
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
return result;
}
Ninja: Backslash rules for Windows Generally these are only required in build statements, as Ninja wants to be able to chop paths up. But it doesn't hurt to also try to use them in command line arguments.
2012-02-19 01:50:53 +00:00
std::string cmGlobalNinjaGenerator::EncodePath(const std::string &path)
{
std::string result = path;
#ifdef _WIN32
Ninja: Use forward slashes for any GCC on Windows (#15439) Any GCC compiler on a Windows host needs forward slashes, not just those built for MinGW.
2015-05-06 22:45:01 +00:00
if (this->IsGCCOnWindows())
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
cmSystemTools::ReplaceString(result, "\\", "/");
else
cmSystemTools::ReplaceString(result, "/", "\\");
Ninja: Backslash rules for Windows Generally these are only required in build statements, as Ninja wants to be able to chop paths up. But it doesn't hurt to also try to use them in command line arguments.
2012-02-19 01:50:53 +00:00
#endif
return EncodeLiteral(result);
}
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
std::string cmGlobalNinjaGenerator::EncodeDepfileSpace(const std::string &path)
{
std::string result = path;
cmSystemTools::ReplaceString(result, " ", "\\ ");
return result;
}
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
void cmGlobalNinjaGenerator::WriteBuild(std::ostream& os,
const std::string& comment,
const std::string& rule,
const cmNinjaDeps& outputs,
const cmNinjaDeps& explicitDeps,
const cmNinjaDeps& implicitDeps,
const cmNinjaDeps& orderOnlyDeps,
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
const cmNinjaVars& variables,
Ninja: don't confuse ninja's rsp files with nmake's Move response files into CMakeFiles/ which makes them different to nmake's.
2012-09-26 08:07:25 +00:00
const std::string& rspfile,
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
int cmdLineLimit)
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
{
// Make sure there is a rule.
if(rule.empty())
{
cmSystemTools::Error("No rule for WriteBuildStatement! called "
"with comment: ",
comment.c_str());
return;
}
// Make sure there is at least one output file.
if(outputs.empty())
{
cmSystemTools::Error("No output files for WriteBuildStatement! called "
"with comment: ",
comment.c_str());
return;
}
cmGlobalNinjaGenerator::WriteComment(os, comment);
ninja: Don't use a stringstream to build an argument list Streams are expensive to construct (looks like some locale-related stuff), so use strings instead.
2014-02-08 05:30:18 +00:00
std::string arguments;
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
// TODO: Better formatting for when there are multiple input/output files.
// Write explicit dependencies.
for(cmNinjaDeps::const_iterator i = explicitDeps.begin();
i != explicitDeps.end();
++i)
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
{
ninja: Don't use a stringstream to build an argument list Streams are expensive to construct (looks like some locale-related stuff), so use strings instead.
2014-02-08 05:30:18 +00:00
arguments += " " + EncodeIdent(EncodePath(*i), os);
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
}
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
// Write implicit dependencies.
if(!implicitDeps.empty())
{
ninja: Don't use a stringstream to build an argument list Streams are expensive to construct (looks like some locale-related stuff), so use strings instead.
2014-02-08 05:30:18 +00:00
arguments += " |";
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
for(cmNinjaDeps::const_iterator i = implicitDeps.begin();
i != implicitDeps.end();
++i)
ninja: Don't use a stringstream to build an argument list Streams are expensive to construct (looks like some locale-related stuff), so use strings instead.
2014-02-08 05:30:18 +00:00
arguments += " " + EncodeIdent(EncodePath(*i), os);
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
// Write order-only dependencies.
if(!orderOnlyDeps.empty())
{
ninja: Don't use a stringstream to build an argument list Streams are expensive to construct (looks like some locale-related stuff), so use strings instead.
2014-02-08 05:30:18 +00:00
arguments += " ||";
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
for(cmNinjaDeps::const_iterator i = orderOnlyDeps.begin();
i != orderOnlyDeps.end();
++i)
ninja: Don't use a stringstream to build an argument list Streams are expensive to construct (looks like some locale-related stuff), so use strings instead.
2014-02-08 05:30:18 +00:00
arguments += " " + EncodeIdent(EncodePath(*i), os);
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
ninja: Don't use a stringstream to build an argument list Streams are expensive to construct (looks like some locale-related stuff), so use strings instead.
2014-02-08 05:30:18 +00:00
arguments += "\n";
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
ninja: Don't use a stringstream to build an argument list Streams are expensive to construct (looks like some locale-related stuff), so use strings instead.
2014-02-08 05:30:18 +00:00
std::string build;
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
// Write outputs files.
ninja: Don't use a stringstream to build an argument list Streams are expensive to construct (looks like some locale-related stuff), so use strings instead.
2014-02-08 05:30:18 +00:00
build += "build";
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
for(cmNinjaDeps::const_iterator i = outputs.begin();
Ninja: also consider variables when checking command line length
2012-07-01 22:01:41 +00:00
i != outputs.end(); ++i)
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
{
ninja: Don't use a stringstream to build an argument list Streams are expensive to construct (looks like some locale-related stuff), so use strings instead.
2014-02-08 05:30:18 +00:00
build += " " + EncodeIdent(EncodePath(*i), os);
Ninja: Add policy to require explicit custom command byproducts Add policy CMP0058 to avoid generating 'phony' ninja rules for unknown custom command dependencies. This requires projects to specify their custom command byproducts explicitly. With this requirement we no longer have to assume that unknown custom command dependencies are generated and can instead simply assume they are source files expected to exist when the build starts. This is particularly important in in-source builds. It is also helpful for out-of-source builds to allow Ninja to diagnose missing files before running custom command rules that depend on them.
2015-03-20 20:43:21 +00:00
if (this->ComputingUnknownDependencies)
{
this->CombinedBuildOutputs.insert( EncodePath(*i) );
}
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
}
ninja: Don't use a stringstream to build an argument list Streams are expensive to construct (looks like some locale-related stuff), so use strings instead.
2014-02-08 05:30:18 +00:00
build += ":";
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
// Write the rule.
ninja: Don't use a stringstream to build an argument list Streams are expensive to construct (looks like some locale-related stuff), so use strings instead.
2014-02-08 05:30:18 +00:00
build += " " + rule;
Ninja: also consider variables when checking command line length
2012-07-01 22:01:41 +00:00
// Write the variables bound to this build statement.
Port all cmOStringStream to std::ostringstream. All compilers hosting CMake support the std class.
2015-01-05 19:31:31 +00:00
std::ostringstream variable_assignments;
Ninja: also consider variables when checking command line length
2012-07-01 22:01:41 +00:00
for(cmNinjaVars::const_iterator i = variables.begin();
i != variables.end(); ++i)
cmGlobalNinjaGenerator::WriteVariable(variable_assignments,
i->first, i->second, "", 1);
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
// check if a response file rule should be used
ninja: Don't use a stringstream to build an argument list Streams are expensive to construct (looks like some locale-related stuff), so use strings instead.
2014-02-08 05:30:18 +00:00
std::string buildstr = build;
Ninja: don't confuse ninja's rsp files with nmake's Move response files into CMakeFiles/ which makes them different to nmake's.
2012-09-26 08:07:25 +00:00
std::string assignments = variable_assignments.str();
ninja: Don't use a stringstream to build an argument list Streams are expensive to construct (looks like some locale-related stuff), so use strings instead.
2014-02-08 05:30:18 +00:00
const std::string& args = arguments;
Ninja: also consider variables when checking command line length
2012-07-01 22:01:41 +00:00
if (cmdLineLimit > 0
&& args.size() + buildstr.size() + assignments.size()
Ninja: don't confuse ninja's rsp files with nmake's Move response files into CMakeFiles/ which makes them different to nmake's.
2012-09-26 08:07:25 +00:00
> (size_t) cmdLineLimit) {
buildstr += "_RSP_FILE";
Ninja: Fix variable duplication in RSP rules Stream clear() resets stream state but does not actually clear its content.
2014-10-06 20:29:09 +00:00
variable_assignments.str(std::string());
Ninja: don't confuse ninja's rsp files with nmake's Move response files into CMakeFiles/ which makes them different to nmake's.
2012-09-26 08:07:25 +00:00
cmGlobalNinjaGenerator::WriteVariable(variable_assignments,
"RSP_FILE", rspfile, "", 1);
assignments += variable_assignments.str();
}
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
Ninja: also consider variables when checking command line length
2012-07-01 22:01:41 +00:00
os << buildstr << args << assignments;
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
void cmGlobalNinjaGenerator::WritePhonyBuild(std::ostream& os,
const std::string& comment,
const cmNinjaDeps& outputs,
const cmNinjaDeps& explicitDeps,
const cmNinjaDeps& implicitDeps,
const cmNinjaDeps& orderOnlyDeps,
const cmNinjaVars& variables)
{
Ninja: GlobalNinjaGenerator WriteBuild and WritePhonyBuild non static To properly track the usage of dependencies that are generated at compile time as the side effect of other build steps we need to make the WriteBuild and WritePhonyBuild commands non static
2013-06-07 18:25:33 +00:00
this->WriteBuild(os,
comment,
"phony",
outputs,
explicitDeps,
implicitDeps,
orderOnlyDeps,
variables);
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
void cmGlobalNinjaGenerator::AddCustomCommandRule()
{
this->AddRule("CUSTOM_COMMAND",
"$COMMAND",
"$DESC",
"Rule for running custom commands.",
/*depfile*/ "",
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
/*deptype*/ "",
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
/*rspfile*/ "",
Ninja: also write link libraries to rsp file and enable rspfile support on Linux, needed for commands longer than e.g. 2096152 characters on Ubuntu.
2012-07-10 07:56:11 +00:00
/*rspcontent*/ "",
Ninja: Refactor restat to be a string internally This will allow values other than "" and "1" to be generated in the rules.ninja file.
2014-11-13 23:32:44 +00:00
/*restat*/ "1",
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
/*generator*/ false);
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
void
cmGlobalNinjaGenerator::WriteCustomCommandBuild(const std::string& command,
const std::string& description,
const std::string& comment,
Ninja: Implement USES_TERMINAL using the console pool if available
2014-11-05 20:42:18 +00:00
bool uses_terminal,
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
const cmNinjaDeps& outputs,
const cmNinjaDeps& deps,
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
const cmNinjaDeps& orderOnly)
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
{
Ninja: don't break because of empty commands
2012-06-05 23:36:34 +00:00
std::string cmd = command;
#ifdef _WIN32
if (cmd.empty())
// TODO Shouldn't an empty command be handled by ninja?
cmd = "cmd.exe /c";
#endif
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
this->AddCustomCommandRule();
cmNinjaVars vars;
Ninja: don't break because of empty commands
2012-06-05 23:36:34 +00:00
vars["COMMAND"] = cmd;
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
vars["DESC"] = EncodeLiteral(description);
Ninja: Implement USES_TERMINAL using the console pool if available
2014-11-05 20:42:18 +00:00
if (uses_terminal && SupportsConsolePool())
{
vars["pool"] = "console";
}
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
Ninja: GlobalNinjaGenerator WriteBuild and WritePhonyBuild non static To properly track the usage of dependencies that are generated at compile time as the side effect of other build steps we need to make the WriteBuild and WritePhonyBuild commands non static
2013-06-07 18:25:33 +00:00
this->WriteBuild(*this->BuildFileStream,
comment,
"CUSTOM_COMMAND",
outputs,
deps,
cmNinjaDeps(),
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
orderOnly,
Ninja: GlobalNinjaGenerator WriteBuild and WritePhonyBuild non static To properly track the usage of dependencies that are generated at compile time as the side effect of other build steps we need to make the WriteBuild and WritePhonyBuild commands non static
2013-06-07 18:25:33 +00:00
vars);
Ninja: Consider only custom commands deps as side-effects (#14972) Since commit v2.8.12~248^2 (Ninja: Custom Command file depends don't need to exist before building, 2013-06-07) all explicit dependencies inside build folder were considered as possible build command side-effects and phony rules were produced for them in case they don't exist when starting to build. This is unnecessary since regular compile inputs need to exist or cmake will fail. Moreover the exception for sources having GENERATED property that can be missing is already handled by WriteAssumedSourceDependencies. This fixes unwanted phony rules for all regular source files when doing in-source build, causing Ninja not complain when such files gets missing, i.e. during development. Also this reduces number of rules in ninja.build. Now only custom command dependencies are considered as possible side-effects.
2014-06-27 20:13:50 +00:00
Ninja: Add policy to require explicit custom command byproducts Add policy CMP0058 to avoid generating 'phony' ninja rules for unknown custom command dependencies. This requires projects to specify their custom command byproducts explicitly. With this requirement we no longer have to assume that unknown custom command dependencies are generated and can instead simply assume they are source files expected to exist when the build starts. This is particularly important in in-source builds. It is also helpful for out-of-source builds to allow Ninja to diagnose missing files before running custom command rules that depend on them.
2015-03-20 20:43:21 +00:00
if (this->ComputingUnknownDependencies)
Ninja: Consider only custom commands deps as side-effects (#14972) Since commit v2.8.12~248^2 (Ninja: Custom Command file depends don't need to exist before building, 2013-06-07) all explicit dependencies inside build folder were considered as possible build command side-effects and phony rules were produced for them in case they don't exist when starting to build. This is unnecessary since regular compile inputs need to exist or cmake will fail. Moreover the exception for sources having GENERATED property that can be missing is already handled by WriteAssumedSourceDependencies. This fixes unwanted phony rules for all regular source files when doing in-source build, causing Ninja not complain when such files gets missing, i.e. during development. Also this reduces number of rules in ninja.build. Now only custom command dependencies are considered as possible side-effects.
2014-06-27 20:13:50 +00:00
{
Ninja: Add policy to require explicit custom command byproducts Add policy CMP0058 to avoid generating 'phony' ninja rules for unknown custom command dependencies. This requires projects to specify their custom command byproducts explicitly. With this requirement we no longer have to assume that unknown custom command dependencies are generated and can instead simply assume they are source files expected to exist when the build starts. This is particularly important in in-source builds. It is also helpful for out-of-source builds to allow Ninja to diagnose missing files before running custom command rules that depend on them.
2015-03-20 20:43:21 +00:00
//we need to track every dependency that comes in, since we are trying
//to find dependencies that are side effects of build commands
for(cmNinjaDeps::const_iterator i = deps.begin(); i != deps.end(); ++i)
{
this->CombinedCustomCommandExplicitDependencies.insert(EncodePath(*i));
}
Ninja: Consider only custom commands deps as side-effects (#14972) Since commit v2.8.12~248^2 (Ninja: Custom Command file depends don't need to exist before building, 2013-06-07) all explicit dependencies inside build folder were considered as possible build command side-effects and phony rules were produced for them in case they don't exist when starting to build. This is unnecessary since regular compile inputs need to exist or cmake will fail. Moreover the exception for sources having GENERATED property that can be missing is already handled by WriteAssumedSourceDependencies. This fixes unwanted phony rules for all regular source files when doing in-source build, causing Ninja not complain when such files gets missing, i.e. during development. Also this reduces number of rules in ninja.build. Now only custom command dependencies are considered as possible side-effects.
2014-06-27 20:13:50 +00:00
}
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
Ninja: Copy resource files in the bundle. This patch fixes test BundleTest on Darwin.
2012-07-10 18:13:01 +00:00
void
cmGlobalNinjaGenerator::AddMacOSXContentRule()
{
cmLocalGenerator *lg = this->LocalGenerators[0];
cmMakefile* mfRoot = lg->GetMakefile();
Port all cmOStringStream to std::ostringstream. All compilers hosting CMake support the std class.
2015-01-05 19:31:31 +00:00
std::ostringstream cmd;
Ninja: Copy resource files in the bundle. This patch fixes test BundleTest on Darwin.
2012-07-10 18:13:01 +00:00
cmd << lg->ConvertToOutputFormat(
mfRoot->GetRequiredDefinition("CMAKE_COMMAND"),
cmLocalGenerator::SHELL)
<< " -E copy $in $out";
this->AddRule("COPY_OSX_CONTENT",
cmd.str(),
"Copying OS X Content $out",
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
"Rule for copying OS X bundle content file.",
Ninja: Copy resource files in the bundle. This patch fixes test BundleTest on Darwin.
2012-07-10 18:13:01 +00:00
/*depfile*/ "",
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
/*deptype*/ "",
/*rspfile*/ "",
/*rspcontent*/ "",
Ninja: Refactor restat to be a string internally This will allow values other than "" and "1" to be generated in the rules.ninja file.
2014-11-13 23:32:44 +00:00
/*restat*/ "",
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
/*generator*/ false);
Ninja: Copy resource files in the bundle. This patch fixes test BundleTest on Darwin.
2012-07-10 18:13:01 +00:00
}
void
cmGlobalNinjaGenerator::WriteMacOSXContentBuild(const std::string& input,
const std::string& output)
{
this->AddMacOSXContentRule();
cmNinjaDeps outputs;
outputs.push_back(output);
cmNinjaDeps deps;
deps.push_back(input);
cmNinjaVars vars;
Ninja: GlobalNinjaGenerator WriteBuild and WritePhonyBuild non static To properly track the usage of dependencies that are generated at compile time as the side effect of other build steps we need to make the WriteBuild and WritePhonyBuild commands non static
2013-06-07 18:25:33 +00:00
this->WriteBuild(*this->BuildFileStream,
"",
"COPY_OSX_CONTENT",
outputs,
deps,
cmNinjaDeps(),
cmNinjaDeps(),
cmNinjaVars());
Ninja: Copy resource files in the bundle. This patch fixes test BundleTest on Darwin.
2012-07-10 18:13:01 +00:00
}
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
void cmGlobalNinjaGenerator::WriteRule(std::ostream& os,
const std::string& name,
const std::string& command,
const std::string& description,
const std::string& comment,
const std::string& depfile,
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
const std::string& deptype,
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
const std::string& rspfile,
Ninja: also write link libraries to rsp file and enable rspfile support on Linux, needed for commands longer than e.g. 2096152 characters on Ubuntu.
2012-07-10 07:56:11 +00:00
const std::string& rspcontent,
Ninja: Refactor restat to be a string internally This will allow values other than "" and "1" to be generated in the rules.ninja file.
2014-11-13 23:32:44 +00:00
const std::string& restat,
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
bool generator)
{
// Make sure the rule has a name.
if(name.empty())
{
cmSystemTools::Error("No name given for WriteRuleStatement! called "
"with comment: ",
comment.c_str());
return;
}
// Make sure a command is given.
if(command.empty())
{
cmSystemTools::Error("No command given for WriteRuleStatement! called "
"with comment: ",
comment.c_str());
return;
}
cmGlobalNinjaGenerator::WriteComment(os, comment);
// Write the rule.
os << "rule " << name << "\n";
// Write the depfile if any.
if(!depfile.empty())
{
cmGlobalNinjaGenerator::Indent(os, 1);
os << "depfile = " << depfile << "\n";
}
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
// Write the deptype if any.
if (!deptype.empty())
{
cmGlobalNinjaGenerator::Indent(os, 1);
os << "deps = " << deptype << "\n";
}
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
// Write the command.
cmGlobalNinjaGenerator::Indent(os, 1);
os << "command = " << command << "\n";
// Write the description if any.
if(!description.empty())
{
cmGlobalNinjaGenerator::Indent(os, 1);
os << "description = " << description << "\n";
}
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
if(!rspfile.empty())
{
Ninja: error on missing rspfile_content
2012-07-10 08:42:24 +00:00
if (rspcontent.empty())
{
cmSystemTools::Error("No rspfile_content given!", comment.c_str());
return;
}
cmGlobalNinjaGenerator::Indent(os, 1);
os << "rspfile = " << rspfile << "\n";
cmGlobalNinjaGenerator::Indent(os, 1);
os << "rspfile_content = " << rspcontent << "\n";
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
}
Ninja: Refactor restat to be a string internally This will allow values other than "" and "1" to be generated in the rules.ninja file.
2014-11-13 23:32:44 +00:00
if(!restat.empty())
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
{
cmGlobalNinjaGenerator::Indent(os, 1);
Ninja: Refactor restat to be a string internally This will allow values other than "" and "1" to be generated in the rules.ninja file.
2014-11-13 23:32:44 +00:00
os << "restat = " << restat << "\n";
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
if(generator)
{
cmGlobalNinjaGenerator::Indent(os, 1);
os << "generator = 1\n";
}
Ninja: don't pollute the rules file with useless comments
2012-06-10 18:20:29 +00:00
os << "\n";
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
void cmGlobalNinjaGenerator::WriteVariable(std::ostream& os,
const std::string& name,
const std::string& value,
const std::string& comment,
int indent)
{
// Make sure we have a name.
if(name.empty())
{
cmSystemTools::Error("No name given for WriteVariable! called "
"with comment: ",
comment.c_str());
return;
}
// Do not add a variable if the value is empty.
std::string val = cmSystemTools::TrimWhitespace(value);
if(val.empty())
{
return;
}
cmGlobalNinjaGenerator::WriteComment(os, comment);
cmGlobalNinjaGenerator::Indent(os, indent);
os << name << " = " << val << "\n";
}
void cmGlobalNinjaGenerator::WriteInclude(std::ostream& os,
const std::string& filename,
const std::string& comment)
{
cmGlobalNinjaGenerator::WriteComment(os, comment);
os << "include " << filename << "\n";
}
void cmGlobalNinjaGenerator::WriteDefault(std::ostream& os,
const cmNinjaDeps& targets,
const std::string& comment)
{
cmGlobalNinjaGenerator::WriteComment(os, comment);
os << "default";
for(cmNinjaDeps::const_iterator i = targets.begin(); i != targets.end(); ++i)
os << " " << *i;
os << "\n";
}
cmGlobalNinjaGenerator::cmGlobalNinjaGenerator()
: cmGlobalGenerator()
, BuildFileStream(0)
, RulesFileStream(0)
Make the CMAKE_EXPORT_COMPILE_COMMANDS option work with Ninja.
2012-05-09 21:47:37 +00:00
, CompileCommandsStream(0)
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
, Rules()
, AllDependencies()
Ninja: Use forward slashes for any GCC on Windows (#15439) Any GCC compiler on a Windows host needs forward slashes, not just those built for MinGW.
2015-05-06 22:45:01 +00:00
, UsingGCCOnWindows(false)
Ninja: Add policy to require explicit custom command byproducts Add policy CMP0058 to avoid generating 'phony' ninja rules for unknown custom command dependencies. This requires projects to specify their custom command byproducts explicitly. With this requirement we no longer have to assume that unknown custom command dependencies are generated and can instead simply assume they are source files expected to exist when the build starts. This is particularly important in in-source builds. It is also helpful for out-of-source builds to allow Ninja to diagnose missing files before running custom command rules that depend on them.
2015-03-20 20:43:21 +00:00
, ComputingUnknownDependencies(false)
, PolicyCMP0058(cmPolicies::WARN)
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
{
// // Ninja is not ported to non-Unix OS yet.
// this->ForceUnixPaths = true;
this->FindMakeProgramFile = "CMakeNinjaFindMake.cmake";
}
Ninja: don't pollute the rules file with useless comments
2012-06-10 18:20:29 +00:00
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
//----------------------------------------------------------------------------
// Virtual public methods.
cmLocalGenerator: Require a parent in the constructor. Pass the parent though cmGlobalGenerator::CreateLocalGenerator. This will make it easy to initialize state scopes independent of cmMakefile.
2015-04-28 05:50:52 +00:00
cmLocalGenerator*
cmGlobalNinjaGenerator::CreateLocalGenerator(cmLocalGenerator* parent)
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
{
cmLocalGenerator: Require a parent in the constructor. Pass the parent though cmGlobalGenerator::CreateLocalGenerator. This will make it easy to initialize state scopes independent of cmMakefile.
2015-04-28 05:50:52 +00:00
cmLocalGenerator* lg = new cmLocalNinjaGenerator(parent);
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
lg->SetGlobalGenerator(this);
return lg;
}
void cmGlobalNinjaGenerator
Make cmGlobalGenerator::GetDocumentation() a static function Making the function static allows us to call it directly, without creating and removing an instance of the generator.
2012-11-19 15:42:24 +00:00
::GetDocumentation(cmDocumentationEntry& entry)
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
{
Make cmGlobalGenerator::GetDocumentation() a static function Making the function static allows us to call it directly, without creating and removing an instance of the generator.
2012-11-19 15:42:24 +00:00
entry.Name = cmGlobalNinjaGenerator::GetActualName();
Ninja: Drop 'experimental' label in documentation This generator is no longer experimental and has been fairly mature for several releases already.
2015-04-14 17:14:50 +00:00
entry.Brief = "Generates build.ninja files.";
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
// Implemented in all cmGlobaleGenerator sub-classes.
// Used in:
// Source/cmLocalGenerator.cxx
// Source/cmake.cxx
void cmGlobalNinjaGenerator::Generate()
{
this->OpenBuildFileStream();
this->OpenRulesFileStream();
Ninja: Add policy to require explicit custom command byproducts Add policy CMP0058 to avoid generating 'phony' ninja rules for unknown custom command dependencies. This requires projects to specify their custom command byproducts explicitly. With this requirement we no longer have to assume that unknown custom command dependencies are generated and can instead simply assume they are source files expected to exist when the build starts. This is particularly important in in-source builds. It is also helpful for out-of-source builds to allow Ninja to diagnose missing files before running custom command rules that depend on them.
2015-03-20 20:43:21 +00:00
this->PolicyCMP0058 =
this->LocalGenerators[0]->GetMakefile()
->GetPolicyStatus(cmPolicies::CMP0058);
this->ComputingUnknownDependencies =
(this->PolicyCMP0058 == cmPolicies::OLD ||
this->PolicyCMP0058 == cmPolicies::WARN);
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
this->cmGlobalGenerator::Generate();
Ninja: Appease various compilers
2012-02-05 01:48:08 +00:00
this->WriteAssumedSourceDependencies();
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
this->WriteTargetAliases(*this->BuildFileStream);
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
this->WriteUnknownExplicitDependencies(*this->BuildFileStream);
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
this->WriteBuiltinTargets(*this->BuildFileStream);
Ninja: mark rules/build file streams failed if error occurred (#13067, #13105) This causes cmGeneratedFileStream to delete the temporary files, rather than overwriting the (working) existing files.
2012-05-16 22:57:09 +00:00
if (cmSystemTools::GetErrorOccuredFlag()) {
this->RulesFileStream->setstate(std::ios_base::failbit);
this->BuildFileStream->setstate(std::ios_base::failbit);
}
Make the CMAKE_EXPORT_COMPILE_COMMANDS option work with Ninja.
2012-05-09 21:47:37 +00:00
this->CloseCompileCommandsStream();
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
this->CloseRulesFileStream();
this->CloseBuildFileStream();
}
void cmGlobalNinjaGenerator
Ninja: the Ninja generator does not support Fortran yet.
2013-03-10 10:36:57 +00:00
::EnableLanguage(std::vector<std::string>const& langs,
Ninja: Refactor detection of MinGW tools on Windows Check for CMAKE_COMPILER_IS_MINGW only after enabling a language when it might actually be set. Previously this worked by accident because the check for working compiler or a second language enabled would cause the code path to be taken. Store UsingMinGW as an instance member of cmGlobalNinjaGenerator so that it is reset on each reconfigure. Otherwise cmake-gui cannot switch between build trees for MinGW or non-MinGW tools.
2015-05-07 18:01:58 +00:00
cmMakefile* mf,
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
bool optional)
{
Ninja: the Ninja generator does not support Fortran yet.
2013-03-10 10:36:57 +00:00
if (std::find(langs.begin(), langs.end(), "Fortran") != langs.end())
{
cmSystemTools::Error("The Ninja generator does not support Fortran yet.");
Ninja: add wrapper for cl to extract dependencies cmcldeps wraps cl and adds /showInclude before calling cl. It parses the output of cl for used headers, drops system headers and writes them to a GCC like dependency file. cmcldeps uses ATM ninja code for process handling, but could be ported later to SystemTools. TODO: Why needs ninja multiple calls in the BuildDepends test?
2012-06-08 14:31:54 +00:00
}
Ninja: Refactor detection of MinGW tools on Windows Check for CMAKE_COMPILER_IS_MINGW only after enabling a language when it might actually be set. Previously this worked by accident because the check for working compiler or a second language enabled would cause the code path to be taken. Store UsingMinGW as an instance member of cmGlobalNinjaGenerator so that it is reset on each reconfigure. Otherwise cmake-gui cannot switch between build trees for MinGW or non-MinGW tools.
2015-05-07 18:01:58 +00:00
this->cmGlobalGenerator::EnableLanguage(langs, mf, optional);
Ninja: Prevent compilers to be silently modified Unlike with Unix Makefiles generator modifying compiler paths was not protected with Ninja generator. It was possible to modify them in the cache without the expected effect on the generated solution. Also activate corresponding tests with Ninja.
2014-09-20 20:37:52 +00:00
for(std::vector<std::string>::const_iterator l = langs.begin();
l != langs.end(); ++l)
{
if(*l == "NONE")
{
continue;
}
Ninja: Refactor detection of MinGW tools on Windows Check for CMAKE_COMPILER_IS_MINGW only after enabling a language when it might actually be set. Previously this worked by accident because the check for working compiler or a second language enabled would cause the code path to be taken. Store UsingMinGW as an instance member of cmGlobalNinjaGenerator so that it is reset on each reconfigure. Otherwise cmake-gui cannot switch between build trees for MinGW or non-MinGW tools.
2015-05-07 18:01:58 +00:00
this->ResolveLanguageCompiler(*l, mf, optional);
Ninja: Prevent compilers to be silently modified Unlike with Unix Makefiles generator modifying compiler paths was not protected with Ninja generator. It was possible to modify them in the cache without the expected effect on the generated solution. Also activate corresponding tests with Ninja.
2014-09-20 20:37:52 +00:00
}
Ninja: Refactor detection of MinGW tools on Windows Check for CMAKE_COMPILER_IS_MINGW only after enabling a language when it might actually be set. Previously this worked by accident because the check for working compiler or a second language enabled would cause the code path to be taken. Store UsingMinGW as an instance member of cmGlobalNinjaGenerator so that it is reset on each reconfigure. Otherwise cmake-gui cannot switch between build trees for MinGW or non-MinGW tools.
2015-05-07 18:01:58 +00:00
#ifdef _WIN32
Ninja: Use forward slashes for any GCC on Windows (#15439) Any GCC compiler on a Windows host needs forward slashes, not just those built for MinGW.
2015-05-06 22:45:01 +00:00
if (mf->IsOn("CMAKE_COMPILER_IS_MINGW") ||
strcmp(mf->GetSafeDefinition("CMAKE_C_COMPILER_ID"), "GNU") == 0 ||
strcmp(mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID"), "GNU") == 0 ||
strcmp(mf->GetSafeDefinition("CMAKE_C_SIMULATE_ID"), "GNU") == 0 ||
strcmp(mf->GetSafeDefinition("CMAKE_CXX_SIMULATE_ID"), "GNU") == 0)
Ninja: Refactor detection of MinGW tools on Windows Check for CMAKE_COMPILER_IS_MINGW only after enabling a language when it might actually be set. Previously this worked by accident because the check for working compiler or a second language enabled would cause the code path to be taken. Store UsingMinGW as an instance member of cmGlobalNinjaGenerator so that it is reset on each reconfigure. Otherwise cmake-gui cannot switch between build trees for MinGW or non-MinGW tools.
2015-05-07 18:01:58 +00:00
{
Ninja: Use forward slashes for any GCC on Windows (#15439) Any GCC compiler on a Windows host needs forward slashes, not just those built for MinGW.
2015-05-06 22:45:01 +00:00
this->UsingGCCOnWindows = true;
Ninja: Refactor detection of MinGW tools on Windows Check for CMAKE_COMPILER_IS_MINGW only after enabling a language when it might actually be set. Previously this worked by accident because the check for working compiler or a second language enabled would cause the code path to be taken. Store UsingMinGW as an instance member of cmGlobalNinjaGenerator so that it is reset on each reconfigure. Otherwise cmake-gui cannot switch between build trees for MinGW or non-MinGW tools.
2015-05-07 18:01:58 +00:00
}
#endif
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
// Implemented by:
// cmGlobalUnixMakefileGenerator3
Add a 'Green Hills MULTI' generator on Windows Green Hills MULTI is an IDE for embedded real-time systems. The IDE's product page can be found here: http://www.ghs.com/products/MULTI_IDE.html It supports cross compiling on ARM, Intel x86, and other architectures with various operating systems. The IDE exists on Linux and Windows host systems, but CMake will currently only generate the project files on Windows host systems.
2015-03-24 05:12:55 +00:00
// cmGlobalGhsMultiGenerator
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
// cmGlobalVisualStudio10Generator
// cmGlobalVisualStudio6Generator
// cmGlobalVisualStudio7Generator
// cmGlobalXCodeGenerator
// Called by:
// cmGlobalGenerator::Build()
cmGlobalGenerator: Cleanup GenerateBuildCommand API All cmGlobalGenerator::GenerateBuildCommand call sites that need to produce a string now generate "cmake --build" commands. The remaining call sites immediately pass the result to cmSystemTools::RunSingleCommand. Avoid the intermediate string and argument parsing by directly producing a vector of strings. Also drop the ignoreErrors argument because no call sites remain that use it.
2013-11-15 18:33:32 +00:00
void cmGlobalNinjaGenerator
::GenerateBuildCommand(std::vector<std::string>& makeCommand,
stringapi: Use strings for program paths
2014-02-24 22:38:55 +00:00
const std::string& makeProgram,
stringapi: Use strings for VS project names
2014-02-07 20:40:05 +00:00
const std::string& /*projectName*/,
stringapi: Use strings for directories
2014-02-24 22:38:30 +00:00
const std::string& /*projectDir*/,
stringapi: Use strings in target name
2014-02-06 22:31:47 +00:00
const std::string& targetName,
stringapi: Pass configuration names as strings
2014-02-10 03:48:34 +00:00
const std::string& /*config*/,
cmGlobalGenerator: Cleanup GenerateBuildCommand API All cmGlobalGenerator::GenerateBuildCommand call sites that need to produce a string now generate "cmake --build" commands. The remaining call sites immediately pass the result to cmSystemTools::RunSingleCommand. Avoid the intermediate string and argument parsing by directly producing a vector of strings. Also drop the ignoreErrors argument because no call sites remain that use it.
2013-11-15 18:33:32 +00:00
bool /*fast*/,
cmake: Teach --build to honor CMAKE_VERBOSE_MAKEFILE for Ninja The Ninja build system does not support a in-file verbositiy switch. Instead teach 'cmake --build' to extract the CMAKE_VERBOSE_MAKEFILE setting and pass it as an optional '-v' argument to Ninja. This can serve as a reasonable fallback. Signed-off-by: Gregor Jasny <gjasny@googlemail.com>
2015-02-26 10:32:26 +00:00
bool verbose,
cmGlobalGenerator: Cleanup GenerateBuildCommand API All cmGlobalGenerator::GenerateBuildCommand call sites that need to produce a string now generate "cmake --build" commands. The remaining call sites immediately pass the result to cmSystemTools::RunSingleCommand. Avoid the intermediate string and argument parsing by directly producing a vector of strings. Also drop the ignoreErrors argument because no call sites remain that use it.
2013-11-15 18:33:32 +00:00
std::vector<std::string> const& makeOptions)
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
{
Teach GenerateBuildCommand to find its own make program Add a cmGlobalGenerator::SelectMakeProgram method to select a caller-provided make program, the CMAKE_MAKE_PROGRAM cache entry, or a generator-provided default. Call it from all implementations of the GenerateBuildCommand method with the corresponding generator's default, if any.
2013-11-13 20:12:06 +00:00
makeCommand.push_back(
this->SelectMakeProgram(makeProgram)
);
cmGlobalGenerator: Cleanup GenerateBuildCommand API All cmGlobalGenerator::GenerateBuildCommand call sites that need to produce a string now generate "cmake --build" commands. The remaining call sites immediately pass the result to cmSystemTools::RunSingleCommand. Avoid the intermediate string and argument parsing by directly producing a vector of strings. Also drop the ignoreErrors argument because no call sites remain that use it.
2013-11-15 18:33:32 +00:00
cmake: Teach --build to honor CMAKE_VERBOSE_MAKEFILE for Ninja The Ninja build system does not support a in-file verbositiy switch. Instead teach 'cmake --build' to extract the CMAKE_VERBOSE_MAKEFILE setting and pass it as an optional '-v' argument to Ninja. This can serve as a reasonable fallback. Signed-off-by: Gregor Jasny <gjasny@googlemail.com>
2015-02-26 10:32:26 +00:00
if(verbose)
{
makeCommand.push_back("-v");
}
cmGlobalGenerator: Cleanup GenerateBuildCommand API All cmGlobalGenerator::GenerateBuildCommand call sites that need to produce a string now generate "cmake --build" commands. The remaining call sites immediately pass the result to cmSystemTools::RunSingleCommand. Avoid the intermediate string and argument parsing by directly producing a vector of strings. Also drop the ignoreErrors argument because no call sites remain that use it.
2013-11-15 18:33:32 +00:00
makeCommand.insert(makeCommand.end(),
makeOptions.begin(), makeOptions.end());
stringapi: Use strings in target name
2014-02-06 22:31:47 +00:00
if(!targetName.empty())
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
{
stringapi: Use strings in target name
2014-02-06 22:31:47 +00:00
if(targetName == "clean")
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
{
cmGlobalGenerator: Cleanup GenerateBuildCommand API All cmGlobalGenerator::GenerateBuildCommand call sites that need to produce a string now generate "cmake --build" commands. The remaining call sites immediately pass the result to cmSystemTools::RunSingleCommand. Avoid the intermediate string and argument parsing by directly producing a vector of strings. Also drop the ignoreErrors argument because no call sites remain that use it.
2013-11-15 18:33:32 +00:00
makeCommand.push_back("-t");
makeCommand.push_back("clean");
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
else
{
cmGlobalGenerator: Cleanup GenerateBuildCommand API All cmGlobalGenerator::GenerateBuildCommand call sites that need to produce a string now generate "cmake --build" commands. The remaining call sites immediately pass the result to cmSystemTools::RunSingleCommand. Avoid the intermediate string and argument parsing by directly producing a vector of strings. Also drop the ignoreErrors argument because no call sites remain that use it.
2013-11-15 18:33:32 +00:00
makeCommand.push_back(targetName);
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
}
}
//----------------------------------------------------------------------------
// Non-virtual public methods.
void cmGlobalNinjaGenerator::AddRule(const std::string& name,
const std::string& command,
const std::string& description,
const std::string& comment,
const std::string& depfile,
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
const std::string& deptype,
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
const std::string& rspfile,
Ninja: also write link libraries to rsp file and enable rspfile support on Linux, needed for commands longer than e.g. 2096152 characters on Ubuntu.
2012-07-10 07:56:11 +00:00
const std::string& rspcontent,
Ninja: Refactor restat to be a string internally This will allow values other than "" and "1" to be generated in the rules.ninja file.
2014-11-13 23:32:44 +00:00
const std::string& restat,
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
bool generator)
{
// Do not add the same rule twice.
if (this->HasRule(name))
Ninja: don't pollute the rules file with useless comments
2012-06-10 18:20:29 +00:00
{
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
return;
Ninja: don't pollute the rules file with useless comments
2012-06-10 18:20:29 +00:00
}
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
this->Rules.insert(name);
cmGlobalNinjaGenerator::WriteRule(*this->RulesFileStream,
name,
command,
description,
comment,
depfile,
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
deptype,
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
rspfile,
Ninja: also write link libraries to rsp file and enable rspfile support on Linux, needed for commands longer than e.g. 2096152 characters on Ubuntu.
2012-07-10 07:56:11 +00:00
rspcontent,
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
restat,
generator);
Ninja: also consider rule command length for rsp file
2012-07-02 08:30:29 +00:00
Ninja: remove int/size_t warning
2012-07-06 07:46:00 +00:00
this->RuleCmdLength[name] = (int) command.size();
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
bool cmGlobalNinjaGenerator::HasRule(const std::string &name)
{
RulesSetType::const_iterator rule = this->Rules.find(name);
return (rule != this->Rules.end());
}
Pre-compute object file names before Ninja generation Implement cmGlobalGenerator::ComputeTargetObjects in the Ninja generator to pre-compute all the object file names. Use the results during generation instead of re-computing it later.
2012-03-13 13:30:23 +00:00
//----------------------------------------------------------------------------
// Private virtual overrides
Refactor tool selection for edit_cache (#14544) Refactor edit_cache tool selection to ask each global generator for its preference. Teach the Ninja generator to always use cmake-gui because Ninja by design cannot run interactive terminal dialogs like ccmake. Teach the Makefile generator to use cmake-gui when also using an "extra" generator whose IDE has no terminal to run ccmake, and otherwise fall back to CMAKE_EDIT_COMMAND selection for normal Makefile build systems.
2013-11-12 13:44:08 +00:00
std::string cmGlobalNinjaGenerator::GetEditCacheCommand() const
{
// Ninja by design does not run interactive tools in the terminal,
// so our only choice is cmake-gui.
return cmSystemTools::GetCMakeGUICommand();
}
cmGlobalGenerator: Extract a ComputeTargetObjectDirectory interface. Make it public for future external calls.
2014-03-12 20:09:20 +00:00
//----------------------------------------------------------------------------
void cmGlobalNinjaGenerator
::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const
{
cmTarget* target = gt->Target;
// Compute full path to object file directory for this target.
Rename local 'dir_max' variables to 'dir' The code is not computing the maximum length directory, as is the case in cmLocalVisualStudioGenerator::ComputeLongestObjectDirectory.
2014-03-17 14:27:01 +00:00
std::string dir;
cmMakefile: Rename GetCurrent{Output,Binary}Directory. Match names used in CMake code.
2015-04-16 19:33:09 +00:00
dir += gt->Makefile->GetCurrentBinaryDirectory();
Rename local 'dir_max' variables to 'dir' The code is not computing the maximum length directory, as is the case in cmLocalVisualStudioGenerator::ComputeLongestObjectDirectory.
2014-03-17 14:27:01 +00:00
dir += "/";
dir += gt->LocalGenerator->GetTargetDirectory(*target);
dir += "/";
gt->ObjectDirectory = dir;
cmGlobalGenerator: Extract a ComputeTargetObjectDirectory interface. Make it public for future external calls.
2014-03-12 20:09:20 +00:00
}
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
//----------------------------------------------------------------------------
// Private methods
void cmGlobalNinjaGenerator::OpenBuildFileStream()
{
// Compute Ninja's build file path.
std::string buildFilePath =
this->GetCMakeInstance()->GetHomeOutputDirectory();
buildFilePath += "/";
buildFilePath += cmGlobalNinjaGenerator::NINJA_BUILD_FILE;
// Get a stream where to generate things.
if (!this->BuildFileStream)
{
this->BuildFileStream = new cmGeneratedFileStream(buildFilePath.c_str());
if (!this->BuildFileStream)
{
// An error message is generated by the constructor if it cannot
// open the file.
return;
}
}
// Write the do not edit header.
this->WriteDisclaimer(*this->BuildFileStream);
// Write a comment about this file.
*this->BuildFileStream
<< "# This file contains all the build statements describing the\n"
<< "# compilation DAG.\n\n"
;
}
void cmGlobalNinjaGenerator::CloseBuildFileStream()
{
if (this->BuildFileStream)
{
delete this->BuildFileStream;
this->BuildFileStream = 0;
}
else
{
cmSystemTools::Error("Build file stream was not open.");
}
}
void cmGlobalNinjaGenerator::OpenRulesFileStream()
{
// Compute Ninja's build file path.
std::string rulesFilePath =
this->GetCMakeInstance()->GetHomeOutputDirectory();
rulesFilePath += "/";
rulesFilePath += cmGlobalNinjaGenerator::NINJA_RULES_FILE;
// Get a stream where to generate things.
if (!this->RulesFileStream)
{
this->RulesFileStream = new cmGeneratedFileStream(rulesFilePath.c_str());
if (!this->RulesFileStream)
{
// An error message is generated by the constructor if it cannot
// open the file.
return;
}
}
// Write the do not edit header.
this->WriteDisclaimer(*this->RulesFileStream);
// Write comment about this file.
*this->RulesFileStream
<< "# This file contains all the rules used to get the outputs files\n"
<< "# built from the input files.\n"
<< "# It is included in the main '" << NINJA_BUILD_FILE << "'.\n\n"
;
}
void cmGlobalNinjaGenerator::CloseRulesFileStream()
{
if (this->RulesFileStream)
{
delete this->RulesFileStream;
this->RulesFileStream = 0;
}
else
{
cmSystemTools::Error("Rules file stream was not open.");
}
}
Make the CMAKE_EXPORT_COMPILE_COMMANDS option work with Ninja.
2012-05-09 21:47:37 +00:00
void cmGlobalNinjaGenerator::AddCXXCompileCommand(
const std::string &commandLine,
const std::string &sourceFile)
{
// Compute Ninja's build file path.
std::string buildFileDir =
this->GetCMakeInstance()->GetHomeOutputDirectory();
if (!this->CompileCommandsStream)
{
std::string buildFilePath = buildFileDir + "/compile_commands.json";
// Get a stream where to generate things.
this->CompileCommandsStream =
new cmGeneratedFileStream(buildFilePath.c_str());
*this->CompileCommandsStream << "[";
} else {
*this->CompileCommandsStream << "," << std::endl;
}
Use full paths in compile_commands.json for out of source builds. Clang tooling requires that paths in the directory and file JSON fields are relative to the directory field, but clang doesn't normalize the paths already. The result is that clang doesn't find the relevant entry for files which begin with ../.
2012-06-18 17:59:33 +00:00
std::string sourceFileName = sourceFile;
if (!cmSystemTools::FileIsFullPath(sourceFileName.c_str()))
{
sourceFileName = cmSystemTools::CollapseFullPath(
strings: Remove redundant calls to std::string::c_str() Replacements were detected and performed by the clang tool remove-cstr-calls on a linux build.
2014-10-15 12:54:05 +00:00
sourceFileName,
Use full paths in compile_commands.json for out of source builds. Clang tooling requires that paths in the directory and file JSON fields are relative to the directory field, but clang doesn't normalize the paths already. The result is that clang doesn't find the relevant entry for files which begin with ../.
2012-06-18 17:59:33 +00:00
this->GetCMakeInstance()->GetHomeOutputDirectory());
}
Make the CMAKE_EXPORT_COMPILE_COMMANDS option work with Ninja.
2012-05-09 21:47:37 +00:00
*this->CompileCommandsStream << "\n{\n"
<< " \"directory\": \""
<< cmGlobalGenerator::EscapeJSON(buildFileDir) << "\",\n"
<< " \"command\": \""
<< cmGlobalGenerator::EscapeJSON(commandLine) << "\",\n"
<< " \"file\": \""
Use full paths in compile_commands.json for out of source builds. Clang tooling requires that paths in the directory and file JSON fields are relative to the directory field, but clang doesn't normalize the paths already. The result is that clang doesn't find the relevant entry for files which begin with ../.
2012-06-18 17:59:33 +00:00
<< cmGlobalGenerator::EscapeJSON(sourceFileName) << "\"\n"
Make the CMAKE_EXPORT_COMPILE_COMMANDS option work with Ninja.
2012-05-09 21:47:37 +00:00
<< "}";
}
void cmGlobalNinjaGenerator::CloseCompileCommandsStream()
{
if (this->CompileCommandsStream)
{
*this->CompileCommandsStream << "\n]";
delete this->CompileCommandsStream;
this->CompileCommandsStream = 0;
}
}
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
void cmGlobalNinjaGenerator::WriteDisclaimer(std::ostream& os)
{
os
<< "# CMAKE generated file: DO NOT EDIT!\n"
<< "# Generated by \"" << this->GetName() << "\""
<< " Generator, CMake Version "
<< cmVersion::GetMajorVersion() << "."
<< cmVersion::GetMinorVersion() << "\n\n";
}
void cmGlobalNinjaGenerator::AddDependencyToAll(cmTarget* target)
{
this->AppendTargetOutputs(target, this->AllDependencies);
}
Ninja: Copy resource files in the bundle. This patch fixes test BundleTest on Darwin.
2012-07-10 18:13:01 +00:00
void cmGlobalNinjaGenerator::AddDependencyToAll(const std::string& input)
{
this->AllDependencies.push_back(input);
}
Ninja: Appease various compilers
2012-02-05 01:48:08 +00:00
void cmGlobalNinjaGenerator::WriteAssumedSourceDependencies()
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
{
for (std::map<std::string, std::set<std::string> >::iterator
i = this->AssumedSourceDependencies.begin();
i != this->AssumedSourceDependencies.end(); ++i) {
Ninja: Appease various compilers
2012-02-05 01:48:08 +00:00
cmNinjaDeps deps;
std::copy(i->second.begin(), i->second.end(), std::back_inserter(deps));
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
WriteCustomCommandBuild(/*command=*/"", /*description=*/"",
"Assume dependencies for generated source file.",
Ninja: Implement USES_TERMINAL using the console pool if available
2014-11-05 20:42:18 +00:00
/*uses_terminal*/false,
Ninja: Appease various compilers
2012-02-05 01:48:08 +00:00
cmNinjaDeps(1, i->first), deps);
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
}
void
cmGlobalNinjaGenerator
Constify handling of target dependencies.
2013-12-10 14:16:23 +00:00
::AppendTargetOutputs(cmTarget const* target, cmNinjaDeps& outputs)
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
{
stringapi: Pass configuration names as strings
2014-02-10 03:48:34 +00:00
std::string configName =
target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
cmLocalNinjaGenerator *ng =
static_cast<cmLocalNinjaGenerator *>(this->LocalGenerators[0]);
OS X: Fix regression handling frameworks for Ninja Fix a regression created by commit 373faae5 (Refactor how bundles and frameworks are supported, 2013-05-05). Since the ninja file isn't aware of how framework symlinks work, we suppress symlink creation and let cmOSXBundleGenerator handle it. Also, use the real name of framework library in build rules as was done before, instead of the symlink.
2013-07-17 05:01:50 +00:00
// for frameworks, we want the real name, not smple name
// frameworks always appear versioned, and the build.ninja
// will always attempt to manage symbolic links instead
// of letting cmOSXBundleGenerator do it.
bool realname = target->IsFrameworkOnApple();
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
switch (target->GetType()) {
case cmTarget::EXECUTABLE:
case cmTarget::SHARED_LIBRARY:
case cmTarget::STATIC_LIBRARY:
case cmTarget::MODULE_LIBRARY:
outputs.push_back(ng->ConvertToNinjaPath(
strings: Remove redundant calls to std::string::c_str() Replacements were detected and performed by the clang tool remove-cstr-calls on a linux build.
2014-10-15 12:54:05 +00:00
target->GetFullPath(configName, false, realname)));
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
break;
Build object library targets in Ninja Treat OBJECT libraries as STATIC libraries but leave out the archive step. The object files will be left behind for reference by other targets later.
2012-03-13 14:05:07 +00:00
case cmTarget::OBJECT_LIBRARY:
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
case cmTarget::UTILITY: {
std::string path = ng->ConvertToNinjaPath(
cmMakefile: Port users of GetStart* methods to new names.
2015-04-16 18:06:54 +00:00
target->GetMakefile()->GetCurrentBinaryDirectory());
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
if (path.empty() || path == ".")
outputs.push_back(target->GetName());
else {
path += "/";
path += target->GetName();
outputs.push_back(path);
}
break;
}
case cmTarget::GLOBAL_TARGET:
// Always use the target in HOME instead of an unused duplicate in a
// subdirectory.
outputs.push_back(target->GetName());
break;
default:
return;
}
}
void
cmGlobalNinjaGenerator
Constify handling of target dependencies.
2013-12-10 14:16:23 +00:00
::AppendTargetDepends(cmTarget const* target, cmNinjaDeps& outputs)
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
{
if (target->GetType() == cmTarget::GLOBAL_TARGET) {
// Global targets only depend on other utilities, which may not appear in
// the TargetDepends set (e.g. "all").
strings: Remove cmStdString references Casts from std::string -> cmStdString were high on the list of things taking up time. Avoid such implicit casts across function calls by just using std::string everywhere. The comment that the symbol name is too long is no longer relevant since modern debuggers alias the templates anyways and the size is a non-issue since the underlying methods are generated since it's inherited.
2014-02-10 05:21:34 +00:00
std::set<std::string> const& utils = target->GetUtilities();
Ninja: Appease various compilers
2012-02-05 01:48:08 +00:00
std::copy(utils.begin(), utils.end(), std::back_inserter(outputs));
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
} else {
cmTargetDependSet const& targetDeps =
this->GetTargetDirectDepends(*target);
for (cmTargetDependSet::const_iterator i = targetDeps.begin();
Add the INTERFACE_LIBRARY target type. This target type only contains INTERFACE_* properties, so it can be used as a structural node. The target-specific commands enforce that they may only be used with the INTERFACE keyword when used with INTERFACE_LIBRARY targets. The old-style target properties matching LINK_INTERFACE_LIBRARIES_<CONFIG> are always ignored for this target type. The name of the INTERFACE_LIBRARY must match a validity generator expression. The validity is similar to that of an ALIAS target, but with the additional restriction that it may not contain double colons. Double colons will carry the meaning of IMPORTED or ALIAS targets in CMake 2.8.13. An ALIAS target may be created for an INTERFACE library. At this point it can not be exported and does not appear in the buildsystem and project files are not created for them. That may be added as a feature in a later commit. The generators need some changes to handle the INTERFACE_LIBRARY targets returned by cmComputeLinkInterface::GetItems. The Ninja generator does not use that API, so it doesn't require changes related to that.
2012-11-02 14:47:40 +00:00
i != targetDeps.end(); ++i)
{
if ((*i)->GetType() == cmTarget::INTERFACE_LIBRARY)
{
continue;
}
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
this->AppendTargetOutputs(*i, outputs);
}
}
}
void cmGlobalNinjaGenerator::AddTargetAlias(const std::string& alias,
cmTarget* target) {
cmNinjaDeps outputs;
this->AppendTargetOutputs(target, outputs);
// Mark the target's outputs as ambiguous to ensure that no other target uses
// the output as an alias.
for (cmNinjaDeps::iterator i = outputs.begin(); i != outputs.end(); ++i)
TargetAliases[*i] = 0;
// Insert the alias into the map. If the alias was already present in the
// map and referred to another target, mark it as ambiguous.
std::pair<TargetAliasMap::iterator, bool> newAlias =
Ninja: build with old vc versions
2012-06-14 16:02:20 +00:00
TargetAliases.insert(std::make_pair(alias, target));
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
if (newAlias.second && newAlias.first->second != target)
newAlias.first->second = 0;
}
void cmGlobalNinjaGenerator::WriteTargetAliases(std::ostream& os)
{
cmGlobalNinjaGenerator::WriteDivider(os);
os << "# Target aliases.\n\n";
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
for (TargetAliasMap::const_iterator i = TargetAliases.begin();
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
i != TargetAliases.end(); ++i) {
// Don't write ambiguous aliases.
if (!i->second)
continue;
cmNinjaDeps deps;
this->AppendTargetOutputs(i->second, deps);
Ninja: GlobalNinjaGenerator WriteBuild and WritePhonyBuild non static To properly track the usage of dependencies that are generated at compile time as the side effect of other build steps we need to make the WriteBuild and WritePhonyBuild commands non static
2013-06-07 18:25:33 +00:00
this->WritePhonyBuild(os,
"",
cmNinjaDeps(1, i->first),
deps);
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
}
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os)
{
Ninja: Add policy to require explicit custom command byproducts Add policy CMP0058 to avoid generating 'phony' ninja rules for unknown custom command dependencies. This requires projects to specify their custom command byproducts explicitly. With this requirement we no longer have to assume that unknown custom command dependencies are generated and can instead simply assume they are source files expected to exist when the build starts. This is particularly important in in-source builds. It is also helpful for out-of-source builds to allow Ninja to diagnose missing files before running custom command rules that depend on them.
2015-03-20 20:43:21 +00:00
if (!this->ComputingUnknownDependencies)
{
return;
}
cmGlobalNinjaGenerator: Optimize handling of known build outputs Teach WriteUnknownExplicitDependencies to take ownership of the set of WriteBuild outputs immediately since no other methods need the data. This avoids re-inserting the whole set into another already populated set.
2015-03-18 20:24:11 +00:00
// We need to collect the set of known build outputs.
// Start with those generated by WriteBuild calls.
// No other method needs this so we can take ownership
// of the set locally and throw it out when we are done.
std::set<std::string> knownDependencies;
knownDependencies.swap(this->CombinedBuildOutputs);
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
//now write out the unknown explicit dependencies.
//union the configured files, evaluations files and the CombinedBuildOutputs,
//and then difference with CombinedExplicitDependencies to find the explicit
//dependencies that we have no rule for
cmGlobalNinjaGenerator::WriteDivider(os);
os << "# Unknown Build Time Dependencies.\n"
<< "# Tell Ninja that they may appear as side effects of build rules\n"
<< "# otherwise ordered by order-only dependencies.\n\n";
//get the list of files that cmake itself has generated as a
//product of configuration.
cmLocalNinjaGenerator *ng =
static_cast<cmLocalNinjaGenerator *>(this->LocalGenerators[0]);
for (std::vector<cmLocalGenerator *>::const_iterator i =
this->LocalGenerators.begin(); i != this->LocalGenerators.end(); ++i)
{
//get the vector of files created by this makefile and convert them
//to ninja paths, which are all relative in respect to the build directory
const std::vector<std::string>& files =
(*i)->GetMakefile()->GetOutputFiles();
typedef std::vector<std::string>::const_iterator vect_it;
for(vect_it j = files.begin(); j != files.end(); ++j)
{
strings: Remove redundant calls to std::string::c_str() Replacements were detected and performed by the clang tool remove-cstr-calls on a linux build.
2014-10-15 12:54:05 +00:00
knownDependencies.insert( ng->ConvertToNinjaPath( *j ) );
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
}
Ninja: Remove CMake includes from explicit depends (#14972) It may happen that CMake include is an explicit dependency for some command, while all CMake includes are set phony in WriteTargetRebuildManifest, this may lead to duplicate phony generate rules which causes ninja warnings. We need to remove implicit CMake includes in WriteUnknownExplicitDependencies. This fixes FindCUDA ninja warnings.
2014-06-13 10:11:06 +00:00
//get list files which are implicit dependencies as well and will be phony
//for rebuild manifest
std::vector<std::string> const& lf = (*i)->GetMakefile()->GetListFiles();
typedef std::vector<std::string>::const_iterator vect_it;
for(vect_it j = lf.begin(); j != lf.end(); ++j)
{
strings: Remove redundant calls to std::string::c_str() Replacements were detected and performed by the clang tool remove-cstr-calls on a linux build.
2014-10-15 12:54:05 +00:00
knownDependencies.insert( ng->ConvertToNinjaPath( *j ) );
Ninja: Remove CMake includes from explicit depends (#14972) It may happen that CMake include is an explicit dependency for some command, while all CMake includes are set phony in WriteTargetRebuildManifest, this may lead to duplicate phony generate rules which causes ninja warnings. We need to remove implicit CMake includes in WriteUnknownExplicitDependencies. This fixes FindCUDA ninja warnings.
2014-06-13 10:11:06 +00:00
}
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
}
Ninja: Remove CMake includes from explicit depends (#14972) It may happen that CMake include is an explicit dependency for some command, while all CMake includes are set phony in WriteTargetRebuildManifest, this may lead to duplicate phony generate rules which causes ninja warnings. We need to remove implicit CMake includes in WriteUnknownExplicitDependencies. This fixes FindCUDA ninja warnings.
2014-06-13 10:11:06 +00:00
knownDependencies.insert( "CMakeCache.txt" );
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
for(std::vector<cmGeneratorExpressionEvaluationFile*>::const_iterator
li = this->EvaluationFiles.begin();
li != this->EvaluationFiles.end();
++li)
{
//get all the files created by generator expressions and convert them
//to ninja paths
std::vector<std::string> files = (*li)->GetFiles();
typedef std::vector<std::string>::const_iterator vect_it;
for(vect_it j = files.begin(); j != files.end(); ++j)
{
strings: Remove redundant calls to std::string::c_str() Replacements were detected and performed by the clang tool remove-cstr-calls on a linux build.
2014-10-15 12:54:05 +00:00
knownDependencies.insert( ng->ConvertToNinjaPath( *j ) );
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
}
}
for(TargetAliasMap::const_iterator i= this->TargetAliases.begin();
i != this->TargetAliases.end();
++i)
{
strings: Remove redundant calls to std::string::c_str() Replacements were detected and performed by the clang tool remove-cstr-calls on a linux build.
2014-10-15 12:54:05 +00:00
knownDependencies.insert( ng->ConvertToNinjaPath(i->first) );
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
}
//remove all source files we know will exist.
typedef std::map<std::string, std::set<std::string> >::const_iterator map_it;
for(map_it i = this->AssumedSourceDependencies.begin();
i != this->AssumedSourceDependencies.end();
++i)
{
strings: Remove redundant calls to std::string::c_str() Replacements were detected and performed by the clang tool remove-cstr-calls on a linux build.
2014-10-15 12:54:05 +00:00
knownDependencies.insert( ng->ConvertToNinjaPath(i->first) );
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
}
Ninja: Consider only custom commands deps as side-effects (#14972) Since commit v2.8.12~248^2 (Ninja: Custom Command file depends don't need to exist before building, 2013-06-07) all explicit dependencies inside build folder were considered as possible build command side-effects and phony rules were produced for them in case they don't exist when starting to build. This is unnecessary since regular compile inputs need to exist or cmake will fail. Moreover the exception for sources having GENERATED property that can be missing is already handled by WriteAssumedSourceDependencies. This fixes unwanted phony rules for all regular source files when doing in-source build, causing Ninja not complain when such files gets missing, i.e. during development. Also this reduces number of rules in ninja.build. Now only custom command dependencies are considered as possible side-effects.
2014-06-27 20:13:50 +00:00
//now we difference with CombinedCustomCommandExplicitDependencies to find
Ninja: Properly convert all paths to unix style before we do set intersection. On windows we had a subset of the paths as unix style and a subset as windows so when doing the set intersection it resulted in the same file being found twice.
2013-07-22 14:32:06 +00:00
//the list of items we know nothing about.
Ninja: Consider only custom commands deps as side-effects (#14972) Since commit v2.8.12~248^2 (Ninja: Custom Command file depends don't need to exist before building, 2013-06-07) all explicit dependencies inside build folder were considered as possible build command side-effects and phony rules were produced for them in case they don't exist when starting to build. This is unnecessary since regular compile inputs need to exist or cmake will fail. Moreover the exception for sources having GENERATED property that can be missing is already handled by WriteAssumedSourceDependencies. This fixes unwanted phony rules for all regular source files when doing in-source build, causing Ninja not complain when such files gets missing, i.e. during development. Also this reduces number of rules in ninja.build. Now only custom command dependencies are considered as possible side-effects.
2014-06-27 20:13:50 +00:00
//We have encoded all the paths in CombinedCustomCommandExplicitDependencies
Ninja: Properly convert all paths to unix style before we do set intersection. On windows we had a subset of the paths as unix style and a subset as windows so when doing the set intersection it resulted in the same file being found twice.
2013-07-22 14:32:06 +00:00
//and knownDependencies so no matter if unix or windows paths they
//should all match now.
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
cmGlobalNinjaGenerator: Fix spelling of "unknown"
2015-03-18 20:44:05 +00:00
std::vector<std::string> unknownExplicitDepends;
Ninja: Consider only custom commands deps as side-effects (#14972) Since commit v2.8.12~248^2 (Ninja: Custom Command file depends don't need to exist before building, 2013-06-07) all explicit dependencies inside build folder were considered as possible build command side-effects and phony rules were produced for them in case they don't exist when starting to build. This is unnecessary since regular compile inputs need to exist or cmake will fail. Moreover the exception for sources having GENERATED property that can be missing is already handled by WriteAssumedSourceDependencies. This fixes unwanted phony rules for all regular source files when doing in-source build, causing Ninja not complain when such files gets missing, i.e. during development. Also this reduces number of rules in ninja.build. Now only custom command dependencies are considered as possible side-effects.
2014-06-27 20:13:50 +00:00
this->CombinedCustomCommandExplicitDependencies.erase("all");
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
Ninja: Consider only custom commands deps as side-effects (#14972) Since commit v2.8.12~248^2 (Ninja: Custom Command file depends don't need to exist before building, 2013-06-07) all explicit dependencies inside build folder were considered as possible build command side-effects and phony rules were produced for them in case they don't exist when starting to build. This is unnecessary since regular compile inputs need to exist or cmake will fail. Moreover the exception for sources having GENERATED property that can be missing is already handled by WriteAssumedSourceDependencies. This fixes unwanted phony rules for all regular source files when doing in-source build, causing Ninja not complain when such files gets missing, i.e. during development. Also this reduces number of rules in ninja.build. Now only custom command dependencies are considered as possible side-effects.
2014-06-27 20:13:50 +00:00
std::set_difference(this->CombinedCustomCommandExplicitDependencies.begin(),
this->CombinedCustomCommandExplicitDependencies.end(),
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
knownDependencies.begin(),
knownDependencies.end(),
cmGlobalNinjaGenerator: Fix spelling of "unknown"
2015-03-18 20:44:05 +00:00
std::back_inserter(unknownExplicitDepends));
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
Ninja: Limit custom command side-effects to build folder Revert commit 7243c951 (Ninja: Don't limit custom cmd side-effects to build folder, 2014-06-27) because it causes every custom command dependency in the source tree to get a phony rule. For large projects these rules get too big for Ninja to handle efficiently. While the original change addressed a valid concern, it did not seem to occur regularly in practice because well-behaved projects generate their side-effects only in the build tree. Until we support explicit specification of side-effects (CMake issue #14963), we will have to use this as a middle-ground.
2014-10-08 12:49:05 +00:00
std::string const rootBuildDirectory =
this->GetCMakeInstance()->GetHomeOutputDirectory();
Ninja: Add policy to require explicit custom command byproducts Add policy CMP0058 to avoid generating 'phony' ninja rules for unknown custom command dependencies. This requires projects to specify their custom command byproducts explicitly. With this requirement we no longer have to assume that unknown custom command dependencies are generated and can instead simply assume they are source files expected to exist when the build starts. This is particularly important in in-source builds. It is also helpful for out-of-source builds to allow Ninja to diagnose missing files before running custom command rules that depend on them.
2015-03-20 20:43:21 +00:00
bool const inSourceBuild =
(rootBuildDirectory == this->GetCMakeInstance()->GetHomeDirectory());
std::vector<std::string> warnExplicitDepends;
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
for (std::vector<std::string>::const_iterator
cmGlobalNinjaGenerator: Fix spelling of "unknown"
2015-03-18 20:44:05 +00:00
i = unknownExplicitDepends.begin();
i != unknownExplicitDepends.end();
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
++i)
{
Ninja: Limit custom command side-effects to build folder Revert commit 7243c951 (Ninja: Don't limit custom cmd side-effects to build folder, 2014-06-27) because it causes every custom command dependency in the source tree to get a phony rule. For large projects these rules get too big for Ninja to handle efficiently. While the original change addressed a valid concern, it did not seem to occur regularly in practice because well-behaved projects generate their side-effects only in the build tree. Until we support explicit specification of side-effects (CMake issue #14963), we will have to use this as a middle-ground.
2014-10-08 12:49:05 +00:00
//verify the file is in the build directory
std::string const absDepPath = cmSystemTools::CollapseFullPath(
strings: Remove redundant calls to std::string::c_str() Replacements were detected and performed by the clang tool remove-cstr-calls on a linux build.
2014-10-15 12:54:05 +00:00
*i, rootBuildDirectory.c_str());
bool const inBuildDir = cmSystemTools::IsSubDirectory(absDepPath,
rootBuildDirectory);
Ninja: Limit custom command side-effects to build folder Revert commit 7243c951 (Ninja: Don't limit custom cmd side-effects to build folder, 2014-06-27) because it causes every custom command dependency in the source tree to get a phony rule. For large projects these rules get too big for Ninja to handle efficiently. While the original change addressed a valid concern, it did not seem to occur regularly in practice because well-behaved projects generate their side-effects only in the build tree. Until we support explicit specification of side-effects (CMake issue #14963), we will have to use this as a middle-ground.
2014-10-08 12:49:05 +00:00
if(inBuildDir)
{
cmNinjaDeps deps(1,*i);
this->WritePhonyBuild(os,
"",
deps,
Ninja: Do not generate circular phony rules (#15454) The phony rules added by commit v2.8.12~248^2 (Ninja: Custom Command file depends don't need to exist before building, 2013-06-07) are circular, e.g. build side-effect: phony side-effect This is not diagnosed by Ninja as of version 1.5, but the dependency does not make sense. Simply drop it and use phony rules of the form build side-effect: phony instead. Reported-by: Daniel Dunbar
2015-03-18 16:51:28 +00:00
cmNinjaDeps());
Ninja: Add policy to require explicit custom command byproducts Add policy CMP0058 to avoid generating 'phony' ninja rules for unknown custom command dependencies. This requires projects to specify their custom command byproducts explicitly. With this requirement we no longer have to assume that unknown custom command dependencies are generated and can instead simply assume they are source files expected to exist when the build starts. This is particularly important in in-source builds. It is also helpful for out-of-source builds to allow Ninja to diagnose missing files before running custom command rules that depend on them.
2015-03-20 20:43:21 +00:00
if (this->PolicyCMP0058 == cmPolicies::WARN &&
!inSourceBuild && warnExplicitDepends.size() < 10)
{
warnExplicitDepends.push_back(*i);
}
Ninja: Limit custom command side-effects to build folder Revert commit 7243c951 (Ninja: Don't limit custom cmd side-effects to build folder, 2014-06-27) because it causes every custom command dependency in the source tree to get a phony rule. For large projects these rules get too big for Ninja to handle efficiently. While the original change addressed a valid concern, it did not seem to occur regularly in practice because well-behaved projects generate their side-effects only in the build tree. Until we support explicit specification of side-effects (CMake issue #14963), we will have to use this as a middle-ground.
2014-10-08 12:49:05 +00:00
}
}
Ninja: Add policy to require explicit custom command byproducts Add policy CMP0058 to avoid generating 'phony' ninja rules for unknown custom command dependencies. This requires projects to specify their custom command byproducts explicitly. With this requirement we no longer have to assume that unknown custom command dependencies are generated and can instead simply assume they are source files expected to exist when the build starts. This is particularly important in in-source builds. It is also helpful for out-of-source builds to allow Ninja to diagnose missing files before running custom command rules that depend on them.
2015-03-20 20:43:21 +00:00
if (!warnExplicitDepends.empty())
{
std::ostringstream w;
Port to static cmPolicies API.
2015-05-03 08:12:10 +00:00
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0058) << "\n"
Ninja: Add policy to require explicit custom command byproducts Add policy CMP0058 to avoid generating 'phony' ninja rules for unknown custom command dependencies. This requires projects to specify their custom command byproducts explicitly. With this requirement we no longer have to assume that unknown custom command dependencies are generated and can instead simply assume they are source files expected to exist when the build starts. This is particularly important in in-source builds. It is also helpful for out-of-source builds to allow Ninja to diagnose missing files before running custom command rules that depend on them.
2015-03-20 20:43:21 +00:00
"This project specifies custom command DEPENDS on files "
"in the build tree that are not specified as the OUTPUT or "
"BYPRODUCTS of any add_custom_command or add_custom_target:\n"
" " << cmJoin(warnExplicitDepends, "\n ") <<
"\n"
"For compatibility with versions of CMake that did not have "
"the BYPRODUCTS option, CMake is generating phony rules for "
"such files to convince 'ninja' to build."
"\n"
"Project authors should add the missing BYPRODUCTS or OUTPUT "
"options to the custom commands that produce these files."
;
this->GetCMakeInstance()->IssueMessage(cmake::AUTHOR_WARNING, w.str());
}
Ninja: Custom Command file depends don't need to exist before building When converting custom commands for the ninja build system we need to make sure that any file dependencies that exist in the build tree are converted to phony targets. This tells ninja that these files might not exist when starting the build, but could be generated during the build. This is done by tracking all dependencies for custom command targets. After all have been written out we remove all items from the set that have been seen as a target, custom command output, an alias, or a file in the source directory. Anything that is left is considered to be a file that will be generated as a side effect of another custom command.
2013-06-07 18:26:03 +00:00
}
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
void cmGlobalNinjaGenerator::WriteBuiltinTargets(std::ostream& os)
{
// Write headers.
cmGlobalNinjaGenerator::WriteDivider(os);
os << "# Built-in targets\n\n";
this->WriteTargetAll(os);
this->WriteTargetRebuildManifest(os);
Ninja: Add a convenient 'clean' target. It has been asked on the mailing list: http://public.kitware.com/pipermail/cmake-developers/2012-April/003805.html
2012-04-19 14:47:48 +00:00
this->WriteTargetClean(os);
Ninja: Add a convenient 'help' target.
2012-04-19 15:07:35 +00:00
this->WriteTargetHelp(os);
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
void cmGlobalNinjaGenerator::WriteTargetAll(std::ostream& os)
{
cmNinjaDeps outputs;
outputs.push_back("all");
Ninja: GlobalNinjaGenerator WriteBuild and WritePhonyBuild non static To properly track the usage of dependencies that are generated at compile time as the side effect of other build steps we need to make the WriteBuild and WritePhonyBuild commands non static
2013-06-07 18:25:33 +00:00
this->WritePhonyBuild(os,
"The main all target.",
outputs,
this->AllDependencies);
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
cmGlobalNinjaGenerator::WriteDefault(os,
outputs,
"Make the all target the default.");
}
void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
{
Ninja: Shell encode various CMake invocations
2012-02-19 03:07:09 +00:00
cmLocalGenerator *lg = this->LocalGenerators[0];
cmMakefile* mfRoot = lg->GetMakefile();
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
Port all cmOStringStream to std::ostringstream. All compilers hosting CMake support the std class.
2015-01-05 19:31:31 +00:00
std::ostringstream cmd;
Ninja: Shell encode various CMake invocations
2012-02-19 03:07:09 +00:00
cmd << lg->ConvertToOutputFormat(
mfRoot->GetRequiredDefinition("CMAKE_COMMAND"),
cmLocalGenerator::SHELL)
<< " -H"
<< lg->ConvertToOutputFormat(mfRoot->GetHomeDirectory(),
cmLocalGenerator::SHELL)
<< " -B"
<< lg->ConvertToOutputFormat(mfRoot->GetHomeOutputDirectory(),
cmLocalGenerator::SHELL);
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
WriteRule(*this->RulesFileStream,
"RERUN_CMAKE",
cmd.str(),
"Re-running CMake...",
"Rule for re-running cmake.",
/*depfile=*/ "",
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
/*deptype=*/ "",
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
/*rspfile=*/ "",
Ninja: also write link libraries to rsp file and enable rspfile support on Linux, needed for commands longer than e.g. 2096152 characters on Ubuntu.
2012-07-10 07:56:11 +00:00
/*rspcontent*/ "",
Ninja: Refactor restat to be a string internally This will allow values other than "" and "1" to be generated in the rules.ninja file.
2014-11-13 23:32:44 +00:00
/*restat=*/ "",
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
/*generator=*/ true);
Ninja: Normalize paths of CMake re-run rule dependencies Send all implicit dependencies through ConvertToNinjaPath. Add CMakeCache.txt before uniquifying the list.
2014-01-21 18:18:40 +00:00
cmLocalNinjaGenerator *ng = static_cast<cmLocalNinjaGenerator *>(lg);
Revert "Ninja: Avoid re-running CMake on next build after regeneration" Revert commit 6fac24d7 (Ninja: Avoid re-running CMake on next build after regeneration, 2014-01-09). The files reported by the method cmMakefile::GetOutputFiles() must cause CMake to re-run only if they are missing and without considering a timestamp. Therefore they cannot be listed as outputs of the re-run rule or Ninja will re-run CMake every time because the timestamp of configure_file outputs does not change. Another solution will have to be found to the original problem.
2014-01-15 21:33:22 +00:00
cmNinjaDeps implicitDeps;
Ninja: Normalize paths of CMake re-run rule dependencies Send all implicit dependencies through ConvertToNinjaPath. Add CMakeCache.txt before uniquifying the list.
2014-01-21 18:18:40 +00:00
for(std::vector<cmLocalGenerator*>::const_iterator i =
this->LocalGenerators.begin(); i != this->LocalGenerators.end(); ++i)
{
std::vector<std::string> const& lf = (*i)->GetMakefile()->GetListFiles();
for(std::vector<std::string>::const_iterator fi = lf.begin();
fi != lf.end(); ++fi)
{
strings: Remove redundant calls to std::string::c_str() Replacements were detected and performed by the clang tool remove-cstr-calls on a linux build.
2014-10-15 12:54:05 +00:00
implicitDeps.push_back(ng->ConvertToNinjaPath(*fi));
Ninja: Normalize paths of CMake re-run rule dependencies Send all implicit dependencies through ConvertToNinjaPath. Add CMakeCache.txt before uniquifying the list.
2014-01-21 18:18:40 +00:00
}
}
implicitDeps.push_back("CMakeCache.txt");
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
std::sort(implicitDeps.begin(), implicitDeps.end());
implicitDeps.erase(std::unique(implicitDeps.begin(), implicitDeps.end()),
implicitDeps.end());
Ninja: Use 'console' pool for CMake re-run if possible (#14915) The pre-defined 'console' pool is a non-buffered pool that runs with a depth of 1. CMake re-run cannot be run concurrently and it will eventually output something. A non-buffered pool allows to get it as soon as possible Also, generate the minimal required version of Ninja in the build file.
2014-10-02 19:21:05 +00:00
cmNinjaVars variables;
// Use 'console' pool to get non buffered output of the CMake re-run call
// Available since Ninja 1.5
Ninja: factor out the test for console pool support
2014-11-05 20:40:14 +00:00
if(SupportsConsolePool())
Ninja: Use 'console' pool for CMake re-run if possible (#14915) The pre-defined 'console' pool is a non-buffered pool that runs with a depth of 1. CMake re-run cannot be run concurrently and it will eventually output something. A non-buffered pool allows to get it as soon as possible Also, generate the minimal required version of Ninja in the build file.
2014-10-02 19:21:05 +00:00
{
variables["pool"] = "console";
}
Ninja: GlobalNinjaGenerator WriteBuild and WritePhonyBuild non static To properly track the usage of dependencies that are generated at compile time as the side effect of other build steps we need to make the WriteBuild and WritePhonyBuild commands non static
2013-06-07 18:25:33 +00:00
this->WriteBuild(os,
"Re-run CMake if any of its inputs changed.",
"RERUN_CMAKE",
Revert "Ninja: Avoid re-running CMake on next build after regeneration" Revert commit 6fac24d7 (Ninja: Avoid re-running CMake on next build after regeneration, 2014-01-09). The files reported by the method cmMakefile::GetOutputFiles() must cause CMake to re-run only if they are missing and without considering a timestamp. Therefore they cannot be listed as outputs of the re-run rule or Ninja will re-run CMake every time because the timestamp of configure_file outputs does not change. Another solution will have to be found to the original problem.
2014-01-15 21:33:22 +00:00
/*outputs=*/ cmNinjaDeps(1, NINJA_BUILD_FILE),
Ninja: GlobalNinjaGenerator WriteBuild and WritePhonyBuild non static To properly track the usage of dependencies that are generated at compile time as the side effect of other build steps we need to make the WriteBuild and WritePhonyBuild commands non static
2013-06-07 18:25:33 +00:00
/*explicitDeps=*/ cmNinjaDeps(),
implicitDeps,
/*orderOnlyDeps=*/ cmNinjaDeps(),
Ninja: Use 'console' pool for CMake re-run if possible (#14915) The pre-defined 'console' pool is a non-buffered pool that runs with a depth of 1. CMake re-run cannot be run concurrently and it will eventually output something. A non-buffered pool allows to get it as soon as possible Also, generate the minimal required version of Ninja in the build file.
2014-10-02 19:21:05 +00:00
variables);
Ninja: GlobalNinjaGenerator WriteBuild and WritePhonyBuild non static To properly track the usage of dependencies that are generated at compile time as the side effect of other build steps we need to make the WriteBuild and WritePhonyBuild commands non static
2013-06-07 18:25:33 +00:00
this->WritePhonyBuild(os,
"A missing CMake input file is not an error.",
implicitDeps,
cmNinjaDeps());
Ninja: Add the Ninja generator
2011-11-11 05:00:49 +00:00
}
Ninja: Add a convenient 'clean' target. It has been asked on the mailing list: http://public.kitware.com/pipermail/cmake-developers/2012-April/003805.html
2012-04-19 14:47:48 +00:00
Ninja: Eclipse and KDevelop fixes for ninja Thx to Claus Klein
2012-06-15 10:14:13 +00:00
std::string cmGlobalNinjaGenerator::ninjaCmd() const
{
cmLocalGenerator* lgen = this->LocalGenerators[0];
if (lgen) {
return lgen->ConvertToOutputFormat(
lgen->GetMakefile()->GetRequiredDefinition("CMAKE_MAKE_PROGRAM"),
cmLocalGenerator::SHELL);
}
return "ninja";
}
Ninja: Use 'console' pool for CMake re-run if possible (#14915) The pre-defined 'console' pool is a non-buffered pool that runs with a depth of 1. CMake re-run cannot be run concurrently and it will eventually output something. A non-buffered pool allows to get it as soon as possible Also, generate the minimal required version of Ninja in the build file.
2014-10-02 19:21:05 +00:00
std::string cmGlobalNinjaGenerator::ninjaVersion() const
{
std::string version;
std::string command = ninjaCmd() + " --version";
cmSystemTools::RunSingleCommand(command.c_str(),
cmSystemTools: Teach RunSingleCommand to separate stdout and stderr Extend the RunSingleCommand signature to capture stdout and stderr separately. Allow both to be captured to the same std::string to preserve existing behavior. Update all call sites to do this so that this refactoring does not introduce functional changes.
2015-04-20 19:36:57 +00:00
&version, 0, 0, 0,
Ninja: Use 'console' pool for CMake re-run if possible (#14915) The pre-defined 'console' pool is a non-buffered pool that runs with a depth of 1. CMake re-run cannot be run concurrently and it will eventually output something. A non-buffered pool allows to get it as soon as possible Also, generate the minimal required version of Ninja in the build file.
2014-10-02 19:21:05 +00:00
cmSystemTools::OUTPUT_NONE);
return version;
}
Ninja: factor out the test for console pool support
2014-11-05 20:40:14 +00:00
bool cmGlobalNinjaGenerator::SupportsConsolePool() const
{
return cmSystemTools::VersionCompare(cmSystemTools::OP_LESS,
ninjaVersion().c_str(), "1.5") == false;
}
Ninja: Add a convenient 'clean' target. It has been asked on the mailing list: http://public.kitware.com/pipermail/cmake-developers/2012-April/003805.html
2012-04-19 14:47:48 +00:00
void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os)
{
WriteRule(*this->RulesFileStream,
"CLEAN",
Remove some c_str() calls. Use the clang RemoveCStrCalls tool to automatically migrate the code. This was only run on linux, so does not have any positive or negative effect on other platforms.
2014-03-10 23:04:11 +00:00
ninjaCmd() + " -t clean",
Ninja: Add a convenient 'clean' target. It has been asked on the mailing list: http://public.kitware.com/pipermail/cmake-developers/2012-April/003805.html
2012-04-19 14:47:48 +00:00
"Cleaning all built files...",
"Rule for cleaning all built files.",
/*depfile=*/ "",
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
/*deptype=*/ "",
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
/*rspfile=*/ "",
Ninja: also write link libraries to rsp file and enable rspfile support on Linux, needed for commands longer than e.g. 2096152 characters on Ubuntu.
2012-07-10 07:56:11 +00:00
/*rspcontent*/ "",
Ninja: Refactor restat to be a string internally This will allow values other than "" and "1" to be generated in the rules.ninja file.
2014-11-13 23:32:44 +00:00
/*restat=*/ "",
Ninja: Add a convenient 'clean' target. It has been asked on the mailing list: http://public.kitware.com/pipermail/cmake-developers/2012-April/003805.html
2012-04-19 14:47:48 +00:00
/*generator=*/ false);
WriteBuild(os,
"Clean all the built files.",
"CLEAN",
/*outputs=*/ cmNinjaDeps(1, "clean"),
/*explicitDeps=*/ cmNinjaDeps(),
/*implicitDeps=*/ cmNinjaDeps(),
/*orderOnlyDeps=*/ cmNinjaDeps(),
/*variables=*/ cmNinjaVars());
}
Ninja: Add a convenient 'help' target.
2012-04-19 15:07:35 +00:00
void cmGlobalNinjaGenerator::WriteTargetHelp(std::ostream& os)
{
WriteRule(*this->RulesFileStream,
"HELP",
Remove some c_str() calls. Use the clang RemoveCStrCalls tool to automatically migrate the code. This was only run on linux, so does not have any positive or negative effect on other platforms.
2014-03-10 23:04:11 +00:00
ninjaCmd() + " -t targets",
Ninja: Add a convenient 'help' target.
2012-04-19 15:07:35 +00:00
"All primary targets available:",
"Rule for printing all primary targets available.",
/*depfile=*/ "",
Ninja: use deps = gcc/msvc feature cmcldeps is now only used for .rc file processing
2013-10-18 10:59:47 +00:00
/*deptype=*/ "",
Ninja: add response file support on Windows When MinGW is used slashes are used for dependencies because ar.exe can't read rsp files with backslashes. Many thx to Claus Klein for starting working on this.
2012-06-05 20:39:42 +00:00
/*rspfile=*/ "",
Ninja: also write link libraries to rsp file and enable rspfile support on Linux, needed for commands longer than e.g. 2096152 characters on Ubuntu.
2012-07-10 07:56:11 +00:00
/*rspcontent*/ "",
Ninja: Refactor restat to be a string internally This will allow values other than "" and "1" to be generated in the rules.ninja file.
2014-11-13 23:32:44 +00:00
/*restat=*/ "",
Ninja: Add a convenient 'help' target.
2012-04-19 15:07:35 +00:00
/*generator=*/ false);
WriteBuild(os,
"Print all primary targets available.",
"HELP",
/*outputs=*/ cmNinjaDeps(1, "help"),
/*explicitDeps=*/ cmNinjaDeps(),
/*implicitDeps=*/ cmNinjaDeps(),
/*orderOnlyDeps=*/ cmNinjaDeps(),
/*variables=*/ cmNinjaVars());
}
Reference in New Issue Copy Permalink