CMake/Source/cmGlobalNinjaGenerator.cxx

1203 lines
38 KiB
C++
Raw Normal View History

2011-11-11 09:00:49 +04:00
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2011 Peter Collingbourne <peter@pcc.me.uk>
Copyright 2011 Nicolas Despres <nicolas.despres@gmail.com>
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#include "cmGeneratedFileStream.h"
#include "cmGeneratorExpressionEvaluationFile.h"
#include "cmGeneratorTarget.h"
2011-11-11 09:00:49 +04:00
#include "cmGlobalNinjaGenerator.h"
#include "cmLocalNinjaGenerator.h"
#include "cmMakefile.h"
#include "cmVersion.h"
#include <algorithm>
2011-11-11 09:00:49 +04: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;
os << "\n#############################################\n";
2011-11-11 09:00:49 +04:00
while((rpos = replace.find('\n', lpos)) != std::string::npos)
{
os << "# " << replace.substr(lpos, rpos - lpos) << "\n";
lpos = rpos + 1;
}
os << "# " << replace.substr(lpos) << "\n\n";
2011-11-11 09:00:49 +04:00
}
static bool IsIdentChar(char c)
{
return
('a' <= c && c <= 'z') ||
('+' <= c && c <= '9') || // +,-./ and numbers
('A' <= c && c <= 'Z') ||
(c == '_') || (c == '$') || (c == '\\') ||
(c == ' ') || (c == ':');
2011-11-11 09:00:49 +04: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;
cmOStringStream names;
2011-11-11 09:00:49 +04:00
names << "ident" << VarNum++;
vars << names.str() << " = " << ident << "\n";
return "$" + names.str();
} else {
std::string result = ident;
cmSystemTools::ReplaceString(result, " ", "$ ");
cmSystemTools::ReplaceString(result, ":", "$:");
return result;
2011-11-11 09:00:49 +04:00
}
}
std::string cmGlobalNinjaGenerator::EncodeLiteral(const std::string &lit)
{
std::string result = lit;
cmSystemTools::ReplaceString(result, "$", "$$");
cmSystemTools::ReplaceString(result, "\n", "$\n");
2011-11-11 09:00:49 +04:00
return result;
}
std::string cmGlobalNinjaGenerator::EncodePath(const std::string &path)
{
std::string result = path;
#ifdef _WIN32
if(UsingMinGW)
cmSystemTools::ReplaceString(result, "\\", "/");
else
cmSystemTools::ReplaceString(result, "/", "\\");
#endif
return EncodeLiteral(result);
}
std::string cmGlobalNinjaGenerator::EncodeDepfileSpace(const std::string &path)
{
std::string result = path;
cmSystemTools::ReplaceString(result, " ", "\\ ");
return result;
}
2011-11-11 09:00:49 +04: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,
const cmNinjaVars& variables,
const std::string& rspfile,
int cmdLineLimit)
2011-11-11 09:00:49 +04: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);
cmOStringStream arguments;
2011-11-11 09:00:49 +04: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)
{
arguments << " " << EncodeIdent(EncodePath(*i), os);
2011-11-11 09:00:49 +04:00
//we need to track every dependency that comes in, since we are trying
//to find dependencies that are side effects of build commands
//
this->CombinedBuildExplicitDependencies.insert( EncodePath(*i) );
}
2011-11-11 09:00:49 +04:00
// Write implicit dependencies.
if(!implicitDeps.empty())
{
arguments << " |";
2011-11-11 09:00:49 +04:00
for(cmNinjaDeps::const_iterator i = implicitDeps.begin();
i != implicitDeps.end();
++i)
arguments << " " << EncodeIdent(EncodePath(*i), os);
2011-11-11 09:00:49 +04:00
}
// Write order-only dependencies.
if(!orderOnlyDeps.empty())
{
arguments << " ||";
2011-11-11 09:00:49 +04:00
for(cmNinjaDeps::const_iterator i = orderOnlyDeps.begin();
i != orderOnlyDeps.end();
++i)
arguments << " " << EncodeIdent(EncodePath(*i), os);
2011-11-11 09:00:49 +04:00
}
arguments << "\n";
cmOStringStream build;
// Write outputs files.
build << "build";
for(cmNinjaDeps::const_iterator i = outputs.begin();
i != outputs.end(); ++i)
{
build << " " << EncodeIdent(EncodePath(*i), os);
this->CombinedBuildOutputs.insert( EncodePath(*i) );
}
build << ":";
2011-11-11 09:00:49 +04:00
// Write the rule.
build << " " << rule;
// Write the variables bound to this build statement.
cmOStringStream variable_assignments;
for(cmNinjaVars::const_iterator i = variables.begin();
i != variables.end(); ++i)
cmGlobalNinjaGenerator::WriteVariable(variable_assignments,
i->first, i->second, "", 1);
// check if a response file rule should be used
std::string buildstr = build.str();
std::string assignments = variable_assignments.str();
const std::string args = arguments.str();
if (cmdLineLimit > 0
&& args.size() + buildstr.size() + assignments.size()
> (size_t) cmdLineLimit) {
buildstr += "_RSP_FILE";
variable_assignments.clear();
cmGlobalNinjaGenerator::WriteVariable(variable_assignments,
"RSP_FILE", rspfile, "", 1);
assignments += variable_assignments.str();
}
2011-11-11 09:00:49 +04:00
os << buildstr << args << assignments;
2011-11-11 09:00:49 +04: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)
{
this->WriteBuild(os,
comment,
"phony",
outputs,
explicitDeps,
implicitDeps,
orderOnlyDeps,
variables);
2011-11-11 09:00:49 +04:00
}
void cmGlobalNinjaGenerator::AddCustomCommandRule()
{
this->AddRule("CUSTOM_COMMAND",
"$COMMAND",
"$DESC",
"Rule for running custom commands.",
/*depfile*/ "",
/*deptype*/ "",
/*rspfile*/ "",
/*rspcontent*/ "",
/*restat*/ true,
/*generator*/ false);
2011-11-11 09:00:49 +04:00
}
void
cmGlobalNinjaGenerator::WriteCustomCommandBuild(const std::string& command,
const std::string& description,
const std::string& comment,
const cmNinjaDeps& outputs,
const cmNinjaDeps& deps,
const cmNinjaDeps& orderOnly)
2011-11-11 09:00:49 +04: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
2011-11-11 09:00:49 +04:00
this->AddCustomCommandRule();
cmNinjaVars vars;
vars["COMMAND"] = cmd;
2011-11-11 09:00:49 +04:00
vars["DESC"] = EncodeLiteral(description);
this->WriteBuild(*this->BuildFileStream,
comment,
"CUSTOM_COMMAND",
outputs,
deps,
cmNinjaDeps(),
orderOnly,
vars);
2011-11-11 09:00:49 +04:00
}
void
cmGlobalNinjaGenerator::AddMacOSXContentRule()
{
cmLocalGenerator *lg = this->LocalGenerators[0];
cmMakefile* mfRoot = lg->GetMakefile();
cmOStringStream cmd;
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",
"Rule for copying OS X bundle content file.",
/*depfile*/ "",
/*deptype*/ "",
/*rspfile*/ "",
/*rspcontent*/ "",
/*restat*/ false,
/*generator*/ false);
}
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;
this->WriteBuild(*this->BuildFileStream,
"",
"COPY_OSX_CONTENT",
outputs,
deps,
cmNinjaDeps(),
cmNinjaDeps(),
cmNinjaVars());
}
2011-11-11 09:00:49 +04: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,
const std::string& deptype,
const std::string& rspfile,
const std::string& rspcontent,
2011-11-11 09:00:49 +04:00
bool restat,
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";
}
// Write the deptype if any.
if (!deptype.empty())
{
cmGlobalNinjaGenerator::Indent(os, 1);
os << "deps = " << deptype << "\n";
}
2011-11-11 09:00:49 +04: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";
}
if(!rspfile.empty())
{
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";
}
2011-11-11 09:00:49 +04:00
if(restat)
{
cmGlobalNinjaGenerator::Indent(os, 1);
os << "restat = 1\n";
}
if(generator)
{
cmGlobalNinjaGenerator::Indent(os, 1);
os << "generator = 1\n";
}
os << "\n";
2011-11-11 09:00:49 +04: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)
, CompileCommandsStream(0)
2011-11-11 09:00:49 +04:00
, Rules()
, AllDependencies()
{
// // Ninja is not ported to non-Unix OS yet.
// this->ForceUnixPaths = true;
this->FindMakeProgramFile = "CMakeNinjaFindMake.cmake";
}
2011-11-11 09:00:49 +04:00
//----------------------------------------------------------------------------
// Virtual public methods.
cmLocalGenerator* cmGlobalNinjaGenerator::CreateLocalGenerator()
{
cmLocalGenerator* lg = new cmLocalNinjaGenerator;
lg->SetGlobalGenerator(this);
return lg;
}
void cmGlobalNinjaGenerator
::GetDocumentation(cmDocumentationEntry& entry)
2011-11-11 09:00:49 +04:00
{
entry.Name = cmGlobalNinjaGenerator::GetActualName();
2011-11-11 09:00:49 +04:00
entry.Brief = "Generates build.ninja files (experimental).";
}
// Implemented in all cmGlobaleGenerator sub-classes.
// Used in:
// Source/cmLocalGenerator.cxx
// Source/cmake.cxx
void cmGlobalNinjaGenerator::Generate()
{
this->OpenBuildFileStream();
this->OpenRulesFileStream();
this->cmGlobalGenerator::Generate();
2012-02-05 05:48:08 +04:00
this->WriteAssumedSourceDependencies();
2011-11-11 09:00:49 +04:00
this->WriteTargetAliases(*this->BuildFileStream);
this->WriteUnknownExplicitDependencies(*this->BuildFileStream);
2011-11-11 09:00:49 +04:00
this->WriteBuiltinTargets(*this->BuildFileStream);
if (cmSystemTools::GetErrorOccuredFlag()) {
this->RulesFileStream->setstate(std::ios_base::failbit);
this->BuildFileStream->setstate(std::ios_base::failbit);
}
this->CloseCompileCommandsStream();
2011-11-11 09:00:49 +04:00
this->CloseRulesFileStream();
this->CloseBuildFileStream();
}
// Implemented in all cmGlobaleGenerator sub-classes.
// Used in:
// Source/cmMakefile.cxx:
void cmGlobalNinjaGenerator
::EnableLanguage(std::vector<std::string>const& langs,
cmMakefile* makefile,
2011-11-11 09:00:49 +04:00
bool optional)
{
if (makefile->IsOn("CMAKE_COMPILER_IS_MINGW"))
2011-11-11 09:00:49 +04:00
{
UsingMinGW = true;
this->EnableMinGWLanguage(makefile);
}
if (std::find(langs.begin(), langs.end(), "Fortran") != langs.end())
{
cmSystemTools::Error("The Ninja generator does not support Fortran yet.");
}
this->cmGlobalGenerator::EnableLanguage(langs, makefile, optional);
2011-11-11 09:00:49 +04:00
}
bool cmGlobalNinjaGenerator::UsingMinGW = false;
2011-11-11 09:00:49 +04:00
// Implemented by:
// cmGlobalUnixMakefileGenerator3
// cmGlobalVisualStudio10Generator
// cmGlobalVisualStudio6Generator
// cmGlobalVisualStudio7Generator
// cmGlobalXCodeGenerator
// Called by:
// cmGlobalGenerator::Build()
void cmGlobalNinjaGenerator
::GenerateBuildCommand(std::vector<std::string>& makeCommand,
const std::string& makeProgram,
const std::string& /*projectName*/,
2014-02-25 02:38:30 +04:00
const std::string& /*projectDir*/,
2014-02-07 02:31:47 +04:00
const std::string& targetName,
const std::string& /*config*/,
bool /*fast*/,
std::vector<std::string> const& makeOptions)
2011-11-11 09:00:49 +04:00
{
makeCommand.push_back(
this->SelectMakeProgram(makeProgram)
);
makeCommand.insert(makeCommand.end(),
makeOptions.begin(), makeOptions.end());
2014-02-07 02:31:47 +04:00
if(!targetName.empty())
2011-11-11 09:00:49 +04:00
{
2014-02-07 02:31:47 +04:00
if(targetName == "clean")
2011-11-11 09:00:49 +04:00
{
makeCommand.push_back("-t");
makeCommand.push_back("clean");
2011-11-11 09:00:49 +04:00
}
else
{
makeCommand.push_back(targetName);
2011-11-11 09:00:49 +04: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,
const std::string& deptype,
const std::string& rspfile,
const std::string& rspcontent,
2011-11-11 09:00:49 +04:00
bool restat,
bool generator)
{
// Do not add the same rule twice.
if (this->HasRule(name))
{
2011-11-11 09:00:49 +04:00
return;
}
2011-11-11 09:00:49 +04:00
this->Rules.insert(name);
cmGlobalNinjaGenerator::WriteRule(*this->RulesFileStream,
name,
command,
description,
comment,
depfile,
deptype,
rspfile,
rspcontent,
2011-11-11 09:00:49 +04:00
restat,
generator);
2012-07-06 11:46:00 +04:00
this->RuleCmdLength[name] = (int) command.size();
2011-11-11 09:00:49 +04:00
}
bool cmGlobalNinjaGenerator::HasRule(const std::string &name)
{
RulesSetType::const_iterator rule = this->Rules.find(name);
return (rule != this->Rules.end());
}
//----------------------------------------------------------------------------
// Private virtual overrides
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();
}
// TODO: Refactor to combine with cmGlobalUnixMakefileGenerator3 impl.
void cmGlobalNinjaGenerator::ComputeTargetObjects(cmGeneratorTarget* gt) const
{
cmTarget* target = gt->Target;
// Compute full path to object file directory for this target.
std::string dir_max;
dir_max += gt->Makefile->GetCurrentOutputDirectory();
dir_max += "/";
dir_max += gt->LocalGenerator->GetTargetDirectory(*target);
dir_max += "/";
gt->ObjectDirectory = dir_max;
std::vector<cmSourceFile*> objectSources;
gt->GetObjectSources(objectSources);
// Compute the name of each object file.
for(std::vector<cmSourceFile*>::iterator
si = objectSources.begin();
si != objectSources.end(); ++si)
{
cmSourceFile* sf = *si;
std::string objectName = gt->LocalGenerator
->GetObjectFileNameWithoutTarget(*sf, dir_max);
gt->AddObject(sf, objectName);
}
}
2011-11-11 09:00:49 +04: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.");
}
}
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;
}
std::string sourceFileName = sourceFile;
if (!cmSystemTools::FileIsFullPath(sourceFileName.c_str()))
{
sourceFileName = cmSystemTools::CollapseFullPath(
sourceFileName.c_str(),
this->GetCMakeInstance()->GetHomeOutputDirectory());
}
*this->CompileCommandsStream << "\n{\n"
<< " \"directory\": \""
<< cmGlobalGenerator::EscapeJSON(buildFileDir) << "\",\n"
<< " \"command\": \""
<< cmGlobalGenerator::EscapeJSON(commandLine) << "\",\n"
<< " \"file\": \""
<< cmGlobalGenerator::EscapeJSON(sourceFileName) << "\"\n"
<< "}";
}
void cmGlobalNinjaGenerator::CloseCompileCommandsStream()
{
if (this->CompileCommandsStream)
{
*this->CompileCommandsStream << "\n]";
delete this->CompileCommandsStream;
this->CompileCommandsStream = 0;
}
}
2011-11-11 09:00:49 +04: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);
}
void cmGlobalNinjaGenerator::AddDependencyToAll(const std::string& input)
{
this->AllDependencies.push_back(input);
}
2012-02-05 05:48:08 +04:00
void cmGlobalNinjaGenerator::WriteAssumedSourceDependencies()
2011-11-11 09:00:49 +04:00
{
for (std::map<std::string, std::set<std::string> >::iterator
i = this->AssumedSourceDependencies.begin();
i != this->AssumedSourceDependencies.end(); ++i) {
2012-02-05 05:48:08 +04:00
cmNinjaDeps deps;
std::copy(i->second.begin(), i->second.end(), std::back_inserter(deps));
2011-11-11 09:00:49 +04:00
WriteCustomCommandBuild(/*command=*/"", /*description=*/"",
"Assume dependencies for generated source file.",
2012-02-05 05:48:08 +04:00
cmNinjaDeps(1, i->first), deps);
2011-11-11 09:00:49 +04:00
}
}
void
cmGlobalNinjaGenerator
::AppendTargetOutputs(cmTarget const* target, cmNinjaDeps& outputs)
2011-11-11 09:00:49 +04:00
{
std::string configName =
target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");
2011-11-11 09:00:49 +04:00
cmLocalNinjaGenerator *ng =
static_cast<cmLocalNinjaGenerator *>(this->LocalGenerators[0]);
// 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();
2011-11-11 09:00:49 +04:00
switch (target->GetType()) {
case cmTarget::EXECUTABLE:
case cmTarget::SHARED_LIBRARY:
case cmTarget::STATIC_LIBRARY:
case cmTarget::MODULE_LIBRARY:
outputs.push_back(ng->ConvertToNinjaPath(
target->GetFullPath(configName, false, realname).c_str()));
2011-11-11 09:00:49 +04:00
break;
case cmTarget::OBJECT_LIBRARY:
2011-11-11 09:00:49 +04:00
case cmTarget::UTILITY: {
std::string path = ng->ConvertToNinjaPath(
target->GetMakefile()->GetStartOutputDirectory());
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
::AppendTargetDepends(cmTarget const* target, cmNinjaDeps& outputs)
2011-11-11 09:00:49 +04: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").
std::set<std::string> const& utils = target->GetUtilities();
2012-02-05 05:48:08 +04:00
std::copy(utils.begin(), utils.end(), std::back_inserter(outputs));
2011-11-11 09:00:49 +04:00
} else {
cmTargetDependSet const& targetDeps =
this->GetTargetDirectDepends(*target);
for (cmTargetDependSet::const_iterator i = targetDeps.begin();
i != targetDeps.end(); ++i)
{
if ((*i)->GetType() == cmTarget::INTERFACE_LIBRARY)
{
continue;
}
2011-11-11 09:00:49 +04: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 =
2012-06-14 20:02:20 +04:00
TargetAliases.insert(std::make_pair(alias, target));
2011-11-11 09:00:49 +04: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";
for (TargetAliasMap::const_iterator i = TargetAliases.begin();
2011-11-11 09:00:49 +04:00
i != TargetAliases.end(); ++i) {
// Don't write ambiguous aliases.
if (!i->second)
continue;
cmNinjaDeps deps;
this->AppendTargetOutputs(i->second, deps);
this->WritePhonyBuild(os,
"",
cmNinjaDeps(1, i->first),
deps);
2011-11-11 09:00:49 +04:00
}
}
void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os)
{
//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]);
std::set<std::string> knownDependencies;
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)
{
knownDependencies.insert( ng->ConvertToNinjaPath( j->c_str() ) );
}
}
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)
{
knownDependencies.insert( ng->ConvertToNinjaPath( j->c_str() ) );
}
}
for(TargetAliasMap::const_iterator i= this->TargetAliases.begin();
i != this->TargetAliases.end();
++i)
{
knownDependencies.insert( ng->ConvertToNinjaPath(i->first.c_str()) );
}
//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)
{
knownDependencies.insert( ng->ConvertToNinjaPath(i->first.c_str()) );
}
//insert outputs from all WirteBuild commands
for(std::set<std::string>::iterator i = this->CombinedBuildOutputs.begin();
i != this->CombinedBuildOutputs.end(); ++i)
{
//these paths have already be encoded when added to CombinedBuildOutputs
knownDependencies.insert(*i);
}
//after we have combined the data into knownDependencies we have no need
//to keep this data around
this->CombinedBuildOutputs.clear();
//now we difference with CombinedBuildExplicitDependencies to find
//the list of items we know nothing about.
//We have encoded all the paths in CombinedBuildExplicitDependencies
//and knownDependencies so no matter if unix or windows paths they
//should all match now.
std::vector<std::string> unkownExplicitDepends;
this->CombinedBuildExplicitDependencies.erase("all");
std::set_difference(this->CombinedBuildExplicitDependencies.begin(),
this->CombinedBuildExplicitDependencies.end(),
knownDependencies.begin(),
knownDependencies.end(),
std::back_inserter(unkownExplicitDepends));
std::string const rootBuildDirectory =
this->GetCMakeInstance()->GetHomeOutputDirectory();
for (std::vector<std::string>::const_iterator
i = unkownExplicitDepends.begin();
i != unkownExplicitDepends.end();
++i)
{
//verify the file is in the build directory
std::string const absDepPath = cmSystemTools::CollapseFullPath(
i->c_str(), rootBuildDirectory.c_str());
bool const inBuildDir = cmSystemTools::IsSubDirectory(absDepPath.c_str(),
rootBuildDirectory.c_str());
if(inBuildDir)
{
cmNinjaDeps deps(1,*i);
this->WritePhonyBuild(os,
"",
deps,
deps);
}
}
}
2011-11-11 09:00:49 +04:00
void cmGlobalNinjaGenerator::WriteBuiltinTargets(std::ostream& os)
{
// Write headers.
cmGlobalNinjaGenerator::WriteDivider(os);
os << "# Built-in targets\n\n";
this->WriteTargetAll(os);
this->WriteTargetRebuildManifest(os);
this->WriteTargetClean(os);
2012-04-19 19:07:35 +04:00
this->WriteTargetHelp(os);
2011-11-11 09:00:49 +04:00
}
void cmGlobalNinjaGenerator::WriteTargetAll(std::ostream& os)
{
cmNinjaDeps outputs;
outputs.push_back("all");
this->WritePhonyBuild(os,
"The main all target.",
outputs,
this->AllDependencies);
2011-11-11 09:00:49 +04:00
cmGlobalNinjaGenerator::WriteDefault(os,
outputs,
"Make the all target the default.");
}
void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
{
cmLocalGenerator *lg = this->LocalGenerators[0];
cmMakefile* mfRoot = lg->GetMakefile();
2011-11-11 09:00:49 +04:00
cmOStringStream cmd;
cmd << lg->ConvertToOutputFormat(
mfRoot->GetRequiredDefinition("CMAKE_COMMAND"),
cmLocalGenerator::SHELL)
<< " -H"
<< lg->ConvertToOutputFormat(mfRoot->GetHomeDirectory(),
cmLocalGenerator::SHELL)
<< " -B"
<< lg->ConvertToOutputFormat(mfRoot->GetHomeOutputDirectory(),
cmLocalGenerator::SHELL);
2011-11-11 09:00:49 +04:00
WriteRule(*this->RulesFileStream,
"RERUN_CMAKE",
cmd.str(),
"Re-running CMake...",
"Rule for re-running cmake.",
/*depfile=*/ "",
/*deptype=*/ "",
/*rspfile=*/ "",
/*rspcontent*/ "",
/*restat=*/ false,
2011-11-11 09:00:49 +04:00
/*generator=*/ true);
cmLocalNinjaGenerator *ng = static_cast<cmLocalNinjaGenerator *>(lg);
cmNinjaDeps implicitDeps;
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)
{
implicitDeps.push_back(ng->ConvertToNinjaPath(fi->c_str()));
}
}
implicitDeps.push_back("CMakeCache.txt");
2011-11-11 09:00:49 +04:00
std::sort(implicitDeps.begin(), implicitDeps.end());
implicitDeps.erase(std::unique(implicitDeps.begin(), implicitDeps.end()),
implicitDeps.end());
this->WriteBuild(os,
"Re-run CMake if any of its inputs changed.",
"RERUN_CMAKE",
/*outputs=*/ cmNinjaDeps(1, NINJA_BUILD_FILE),
/*explicitDeps=*/ cmNinjaDeps(),
implicitDeps,
/*orderOnlyDeps=*/ cmNinjaDeps(),
/*variables=*/ cmNinjaVars());
this->WritePhonyBuild(os,
"A missing CMake input file is not an error.",
implicitDeps,
cmNinjaDeps());
2011-11-11 09:00:49 +04: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";
}
void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os)
{
WriteRule(*this->RulesFileStream,
"CLEAN",
ninjaCmd() + " -t clean",
"Cleaning all built files...",
"Rule for cleaning all built files.",
/*depfile=*/ "",
/*deptype=*/ "",
/*rspfile=*/ "",
/*rspcontent*/ "",
/*restat=*/ false,
/*generator=*/ false);
WriteBuild(os,
"Clean all the built files.",
"CLEAN",
/*outputs=*/ cmNinjaDeps(1, "clean"),
/*explicitDeps=*/ cmNinjaDeps(),
/*implicitDeps=*/ cmNinjaDeps(),
/*orderOnlyDeps=*/ cmNinjaDeps(),
/*variables=*/ cmNinjaVars());
}
2012-04-19 19:07:35 +04:00
void cmGlobalNinjaGenerator::WriteTargetHelp(std::ostream& os)
{
WriteRule(*this->RulesFileStream,
"HELP",
ninjaCmd() + " -t targets",
2012-04-19 19:07:35 +04:00
"All primary targets available:",
"Rule for printing all primary targets available.",
/*depfile=*/ "",
/*deptype=*/ "",
/*rspfile=*/ "",
/*rspcontent*/ "",
2012-04-19 19:07:35 +04:00
/*restat=*/ false,
/*generator=*/ false);
WriteBuild(os,
"Print all primary targets available.",
"HELP",
/*outputs=*/ cmNinjaDeps(1, "help"),
/*explicitDeps=*/ cmNinjaDeps(),
/*implicitDeps=*/ cmNinjaDeps(),
/*orderOnlyDeps=*/ cmNinjaDeps(),
/*variables=*/ cmNinjaVars());
}