6e2a4087f2
In the Ninja generator we run all build rules from the top of the build tree rather than changing into each subdirectory. Therefore we convert all paths relative to the HOME_OUTPUT directory. However, the Convert method on cmLocalGenerator restricts relative path conversions to avoid leaving the build tree with a "../" sequence. Therefore conversions performed for "subdirectories" that are outside the top of the build tree always use full paths while conversions performed for subdirectories that are inside the top of the build tree may use relative paths to refer to the same files. Since Ninja always runs rules from the top of the build tree we should convert them using only the top-level cmLocalGenerator in order to remain consistent. Also extend the test suite with a case that fails without this fix.
519 lines
16 KiB
C++
519 lines
16 KiB
C++
/*============================================================================
|
|
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 "cmLocalNinjaGenerator.h"
|
|
#include "cmCustomCommandGenerator.h"
|
|
#include "cmMakefile.h"
|
|
#include "cmGlobalNinjaGenerator.h"
|
|
#include "cmNinjaTargetGenerator.h"
|
|
#include "cmGeneratedFileStream.h"
|
|
#include "cmSourceFile.h"
|
|
#include "cmake.h"
|
|
#include "cmState.h"
|
|
|
|
#include <assert.h>
|
|
|
|
cmLocalNinjaGenerator::cmLocalNinjaGenerator(cmGlobalGenerator* gg,
|
|
cmMakefile* mf)
|
|
: cmLocalCommonGenerator(gg, mf)
|
|
, HomeRelativeOutputPath("")
|
|
{
|
|
this->TargetImplib = "$TARGET_IMPLIB";
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Virtual public methods.
|
|
|
|
cmLocalNinjaGenerator::~cmLocalNinjaGenerator()
|
|
{
|
|
}
|
|
|
|
void cmLocalNinjaGenerator::Generate()
|
|
{
|
|
// Compute the path to use when referencing the current output
|
|
// directory from the top output directory.
|
|
this->HomeRelativeOutputPath =
|
|
this->Convert(this->Makefile->GetCurrentBinaryDirectory(), HOME_OUTPUT);
|
|
if(this->HomeRelativeOutputPath == ".")
|
|
{
|
|
this->HomeRelativeOutputPath = "";
|
|
}
|
|
|
|
this->SetConfigName();
|
|
|
|
this->WriteProcessedMakefile(this->GetBuildFileStream());
|
|
#ifdef NINJA_GEN_VERBOSE_FILES
|
|
this->WriteProcessedMakefile(this->GetRulesFileStream());
|
|
#endif
|
|
|
|
// We do that only once for the top CMakeLists.txt file.
|
|
if(this->Makefile->IsRootMakefile())
|
|
{
|
|
this->WriteBuildFileTop();
|
|
|
|
this->WritePools(this->GetRulesFileStream());
|
|
|
|
const std::string showIncludesPrefix = this->GetMakefile()
|
|
->GetSafeDefinition("CMAKE_CL_SHOWINCLUDES_PREFIX");
|
|
if (!showIncludesPrefix.empty())
|
|
{
|
|
cmGlobalNinjaGenerator::WriteComment(this->GetRulesFileStream(),
|
|
"localized /showIncludes string");
|
|
this->GetRulesFileStream()
|
|
<< "msvc_deps_prefix = " << showIncludesPrefix << "\n\n";
|
|
}
|
|
}
|
|
|
|
cmGeneratorTargetsType targets = this->GetMakefile()->GetGeneratorTargets();
|
|
for(cmGeneratorTargetsType::iterator t = targets.begin();
|
|
t != targets.end(); ++t)
|
|
{
|
|
if (t->second->Target->GetType() == cmTarget::INTERFACE_LIBRARY
|
|
|| t->second->Target->IsImported())
|
|
{
|
|
continue;
|
|
}
|
|
cmNinjaTargetGenerator* tg = cmNinjaTargetGenerator::New(t->second);
|
|
if(tg)
|
|
{
|
|
tg->Generate();
|
|
// Add the target to "all" if required.
|
|
if (!this->GetGlobalNinjaGenerator()->IsExcluded(
|
|
this->GetGlobalNinjaGenerator()->GetLocalGenerators()[0],
|
|
t->second))
|
|
this->GetGlobalNinjaGenerator()->AddDependencyToAll(t->second->Target);
|
|
delete tg;
|
|
}
|
|
}
|
|
|
|
this->WriteCustomCommandBuildStatements();
|
|
}
|
|
|
|
// TODO: Picked up from cmLocalUnixMakefileGenerator3. Refactor it.
|
|
std::string cmLocalNinjaGenerator
|
|
::GetTargetDirectory(cmTarget const& target) const
|
|
{
|
|
std::string dir = cmake::GetCMakeFilesDirectoryPostSlash();
|
|
dir += target.GetName();
|
|
#if defined(__VMS)
|
|
dir += "_dir";
|
|
#else
|
|
dir += ".dir";
|
|
#endif
|
|
return dir;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Non-virtual public methods.
|
|
|
|
const cmGlobalNinjaGenerator*
|
|
cmLocalNinjaGenerator::GetGlobalNinjaGenerator() const
|
|
{
|
|
return
|
|
static_cast<const cmGlobalNinjaGenerator*>(this->GetGlobalGenerator());
|
|
}
|
|
|
|
cmGlobalNinjaGenerator* cmLocalNinjaGenerator::GetGlobalNinjaGenerator()
|
|
{
|
|
return static_cast<cmGlobalNinjaGenerator*>(this->GetGlobalGenerator());
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Virtual protected methods.
|
|
|
|
std::string
|
|
cmLocalNinjaGenerator::ConvertToLinkReference(std::string const& lib,
|
|
OutputFormat format)
|
|
{
|
|
return this->Convert(lib, HOME_OUTPUT, format);
|
|
}
|
|
|
|
std::string
|
|
cmLocalNinjaGenerator::ConvertToIncludeReference(std::string const& path,
|
|
OutputFormat format,
|
|
bool forceFullPaths)
|
|
{
|
|
return this->Convert(path, forceFullPaths? FULL : HOME_OUTPUT, format);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Private methods.
|
|
|
|
cmGeneratedFileStream& cmLocalNinjaGenerator::GetBuildFileStream() const
|
|
{
|
|
return *this->GetGlobalNinjaGenerator()->GetBuildFileStream();
|
|
}
|
|
|
|
cmGeneratedFileStream& cmLocalNinjaGenerator::GetRulesFileStream() const
|
|
{
|
|
return *this->GetGlobalNinjaGenerator()->GetRulesFileStream();
|
|
}
|
|
|
|
const cmake* cmLocalNinjaGenerator::GetCMakeInstance() const
|
|
{
|
|
return this->GetGlobalGenerator()->GetCMakeInstance();
|
|
}
|
|
|
|
cmake* cmLocalNinjaGenerator::GetCMakeInstance()
|
|
{
|
|
return this->GetGlobalGenerator()->GetCMakeInstance();
|
|
}
|
|
|
|
void cmLocalNinjaGenerator::WriteBuildFileTop()
|
|
{
|
|
// For the build file.
|
|
this->WriteProjectHeader(this->GetBuildFileStream());
|
|
this->WriteNinjaRequiredVersion(this->GetBuildFileStream());
|
|
this->WriteNinjaFilesInclusion(this->GetBuildFileStream());
|
|
|
|
// For the rule file.
|
|
this->WriteProjectHeader(this->GetRulesFileStream());
|
|
}
|
|
|
|
void cmLocalNinjaGenerator::WriteProjectHeader(std::ostream& os)
|
|
{
|
|
cmGlobalNinjaGenerator::WriteDivider(os);
|
|
os
|
|
<< "# Project: " << this->GetMakefile()->GetProjectName() << std::endl
|
|
<< "# Configuration: " << this->ConfigName << std::endl
|
|
;
|
|
cmGlobalNinjaGenerator::WriteDivider(os);
|
|
}
|
|
|
|
void cmLocalNinjaGenerator::WriteNinjaRequiredVersion(std::ostream& os)
|
|
{
|
|
// Default required version
|
|
std::string requiredVersion =
|
|
this->GetGlobalNinjaGenerator()->RequiredNinjaVersion();
|
|
|
|
// Ninja generator uses the 'console' pool if available (>= 1.5)
|
|
if(this->GetGlobalNinjaGenerator()->SupportsConsolePool())
|
|
{
|
|
requiredVersion =
|
|
this->GetGlobalNinjaGenerator()->RequiredNinjaVersionForConsolePool();
|
|
}
|
|
|
|
cmGlobalNinjaGenerator::WriteComment(os,
|
|
"Minimal version of Ninja required by this file");
|
|
os
|
|
<< "ninja_required_version = "
|
|
<< requiredVersion
|
|
<< std::endl << std::endl
|
|
;
|
|
}
|
|
|
|
void cmLocalNinjaGenerator::WritePools(std::ostream& os)
|
|
{
|
|
cmGlobalNinjaGenerator::WriteDivider(os);
|
|
|
|
const char* jobpools = this->GetCMakeInstance()->GetState()
|
|
->GetGlobalProperty("JOB_POOLS");
|
|
if (jobpools)
|
|
{
|
|
cmGlobalNinjaGenerator::WriteComment(os,
|
|
"Pools defined by global property JOB_POOLS");
|
|
std::vector<std::string> pools;
|
|
cmSystemTools::ExpandListArgument(jobpools, pools);
|
|
for (size_t i = 0; i < pools.size(); ++i)
|
|
{
|
|
const std::string pool = pools[i];
|
|
const std::string::size_type eq = pool.find("=");
|
|
unsigned int jobs;
|
|
if (eq != std::string::npos &&
|
|
sscanf(pool.c_str() + eq, "=%u", &jobs) == 1)
|
|
{
|
|
os << "pool " << pool.substr(0, eq) << std::endl;
|
|
os << " depth = " << jobs << std::endl;
|
|
os << std::endl;
|
|
}
|
|
else
|
|
{
|
|
cmSystemTools::Error("Invalid pool defined by property 'JOB_POOLS': ",
|
|
pool.c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void cmLocalNinjaGenerator::WriteNinjaFilesInclusion(std::ostream& os)
|
|
{
|
|
cmGlobalNinjaGenerator::WriteDivider(os);
|
|
os
|
|
<< "# Include auxiliary files.\n"
|
|
<< "\n"
|
|
;
|
|
cmGlobalNinjaGenerator::WriteInclude(os,
|
|
cmGlobalNinjaGenerator::NINJA_RULES_FILE,
|
|
"Include rules file.");
|
|
os << "\n";
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void cmLocalNinjaGenerator::ComputeObjectFilenames(
|
|
std::map<cmSourceFile const*, std::string>& mapping,
|
|
cmGeneratorTarget const* gt)
|
|
{
|
|
for(std::map<cmSourceFile const*, std::string>::iterator
|
|
si = mapping.begin(); si != mapping.end(); ++si)
|
|
{
|
|
cmSourceFile const* sf = si->first;
|
|
si->second = this->GetObjectFileNameWithoutTarget(*sf,
|
|
gt->ObjectDirectory);
|
|
}
|
|
}
|
|
|
|
void cmLocalNinjaGenerator::WriteProcessedMakefile(std::ostream& os)
|
|
{
|
|
cmGlobalNinjaGenerator::WriteDivider(os);
|
|
os
|
|
<< "# Write statements declared in CMakeLists.txt:" << std::endl
|
|
<< "# "
|
|
<< this->Makefile->GetDefinition("CMAKE_CURRENT_LIST_FILE") << std::endl;
|
|
if(this->Makefile->IsRootMakefile())
|
|
os << "# Which is the root file." << std::endl;
|
|
cmGlobalNinjaGenerator::WriteDivider(os);
|
|
os << std::endl;
|
|
}
|
|
|
|
void
|
|
cmLocalNinjaGenerator
|
|
::AppendTargetOutputs(cmTarget* target, cmNinjaDeps& outputs)
|
|
{
|
|
this->GetGlobalNinjaGenerator()->AppendTargetOutputs(target, outputs);
|
|
}
|
|
|
|
void
|
|
cmLocalNinjaGenerator
|
|
::AppendTargetDepends(cmTarget* target, cmNinjaDeps& outputs)
|
|
{
|
|
this->GetGlobalNinjaGenerator()->AppendTargetDepends(target, outputs);
|
|
}
|
|
|
|
void cmLocalNinjaGenerator::AppendCustomCommandDeps(
|
|
cmCustomCommandGenerator const& ccg,
|
|
cmNinjaDeps &ninjaDeps)
|
|
{
|
|
const std::vector<std::string> &deps = ccg.GetDepends();
|
|
for (std::vector<std::string>::const_iterator i = deps.begin();
|
|
i != deps.end(); ++i) {
|
|
std::string dep;
|
|
if (this->GetRealDependency(*i, this->GetConfigName(), dep))
|
|
ninjaDeps.push_back(
|
|
this->GetGlobalNinjaGenerator()->ConvertToNinjaPath(dep));
|
|
}
|
|
}
|
|
|
|
std::string cmLocalNinjaGenerator::BuildCommandLine(
|
|
const std::vector<std::string> &cmdLines)
|
|
{
|
|
// If we have no commands but we need to build a command anyway, use ":".
|
|
// This happens when building a POST_BUILD value for link targets that
|
|
// don't use POST_BUILD.
|
|
if (cmdLines.empty())
|
|
#ifdef _WIN32
|
|
return "cd .";
|
|
#else
|
|
return ":";
|
|
#endif
|
|
|
|
std::ostringstream cmd;
|
|
for (std::vector<std::string>::const_iterator li = cmdLines.begin();
|
|
li != cmdLines.end(); ++li)
|
|
#ifdef _WIN32
|
|
{
|
|
if (li != cmdLines.begin())
|
|
{
|
|
cmd << " && ";
|
|
}
|
|
else if (cmdLines.size() > 1)
|
|
{
|
|
cmd << "cmd.exe /C \"";
|
|
}
|
|
cmd << *li;
|
|
}
|
|
if (cmdLines.size() > 1)
|
|
{
|
|
cmd << "\"";
|
|
}
|
|
#else
|
|
{
|
|
if (li != cmdLines.begin())
|
|
{
|
|
cmd << " && ";
|
|
}
|
|
cmd << *li;
|
|
}
|
|
#endif
|
|
return cmd.str();
|
|
}
|
|
|
|
void cmLocalNinjaGenerator::AppendCustomCommandLines(
|
|
cmCustomCommandGenerator const& ccg,
|
|
std::vector<std::string> &cmdLines)
|
|
{
|
|
if (ccg.GetNumberOfCommands() > 0) {
|
|
std::string wd = ccg.GetWorkingDirectory();
|
|
if (wd.empty())
|
|
wd = this->GetMakefile()->GetCurrentBinaryDirectory();
|
|
|
|
std::ostringstream cdCmd;
|
|
#ifdef _WIN32
|
|
std::string cdStr = "cd /D ";
|
|
#else
|
|
std::string cdStr = "cd ";
|
|
#endif
|
|
cdCmd << cdStr << this->ConvertToOutputFormat(wd, SHELL);
|
|
cmdLines.push_back(cdCmd.str());
|
|
}
|
|
|
|
std::string launcher = this->MakeCustomLauncher(ccg);
|
|
|
|
for (unsigned i = 0; i != ccg.GetNumberOfCommands(); ++i) {
|
|
cmdLines.push_back(launcher +
|
|
this->ConvertToOutputFormat(ccg.GetCommand(i), SHELL));
|
|
|
|
std::string& cmd = cmdLines.back();
|
|
ccg.AppendArguments(i, cmd);
|
|
}
|
|
}
|
|
|
|
void
|
|
cmLocalNinjaGenerator::WriteCustomCommandBuildStatement(
|
|
cmCustomCommand const *cc, const cmNinjaDeps& orderOnlyDeps)
|
|
{
|
|
if (this->GetGlobalNinjaGenerator()->SeenCustomCommand(cc))
|
|
return;
|
|
|
|
cmCustomCommandGenerator ccg(*cc, this->GetConfigName(), this);
|
|
|
|
const std::vector<std::string> &outputs = ccg.GetOutputs();
|
|
const std::vector<std::string> &byproducts = ccg.GetByproducts();
|
|
cmNinjaDeps ninjaOutputs(outputs.size()+byproducts.size()), ninjaDeps;
|
|
|
|
#if 0
|
|
#error TODO: Once CC in an ExternalProject target must provide the \
|
|
file of each imported target that has an add_dependencies pointing \
|
|
at us. How to know which ExternalProject step actually provides it?
|
|
#endif
|
|
std::transform(outputs.begin(), outputs.end(),
|
|
ninjaOutputs.begin(),
|
|
this->GetGlobalNinjaGenerator()->MapToNinjaPath());
|
|
std::transform(byproducts.begin(), byproducts.end(),
|
|
ninjaOutputs.begin() + outputs.size(),
|
|
this->GetGlobalNinjaGenerator()->MapToNinjaPath());
|
|
this->AppendCustomCommandDeps(ccg, ninjaDeps);
|
|
|
|
for (cmNinjaDeps::iterator i = ninjaOutputs.begin(); i != ninjaOutputs.end();
|
|
++i)
|
|
this->GetGlobalNinjaGenerator()->SeenCustomCommandOutput(*i);
|
|
|
|
std::vector<std::string> cmdLines;
|
|
this->AppendCustomCommandLines(ccg, cmdLines);
|
|
|
|
if (cmdLines.empty()) {
|
|
this->GetGlobalNinjaGenerator()->WritePhonyBuild(
|
|
this->GetBuildFileStream(),
|
|
"Phony custom command for " +
|
|
ninjaOutputs[0],
|
|
ninjaOutputs,
|
|
ninjaDeps,
|
|
cmNinjaDeps(),
|
|
orderOnlyDeps,
|
|
cmNinjaVars());
|
|
} else {
|
|
this->GetGlobalNinjaGenerator()->WriteCustomCommandBuild(
|
|
this->BuildCommandLine(cmdLines),
|
|
this->ConstructComment(ccg),
|
|
"Custom command for " + ninjaOutputs[0],
|
|
cc->GetUsesTerminal(),
|
|
ninjaOutputs,
|
|
ninjaDeps,
|
|
orderOnlyDeps);
|
|
}
|
|
}
|
|
|
|
void cmLocalNinjaGenerator::AddCustomCommandTarget(cmCustomCommand const* cc,
|
|
cmTarget* target)
|
|
{
|
|
this->CustomCommandTargets[cc].insert(target);
|
|
}
|
|
|
|
void cmLocalNinjaGenerator::WriteCustomCommandBuildStatements()
|
|
{
|
|
for (CustomCommandTargetMap::iterator i = this->CustomCommandTargets.begin();
|
|
i != this->CustomCommandTargets.end(); ++i) {
|
|
// A custom command may appear on multiple targets. However, some build
|
|
// systems exist where the target dependencies on some of the targets are
|
|
// overspecified, leading to a dependency cycle. If we assume all target
|
|
// dependencies are a superset of the true target dependencies for this
|
|
// custom command, we can take the set intersection of all target
|
|
// dependencies to obtain a correct dependency list.
|
|
//
|
|
// FIXME: This won't work in certain obscure scenarios involving indirect
|
|
// dependencies.
|
|
std::set<cmTarget*>::iterator j = i->second.begin();
|
|
assert(j != i->second.end());
|
|
std::vector<std::string> ccTargetDeps;
|
|
this->AppendTargetDepends(*j, ccTargetDeps);
|
|
std::sort(ccTargetDeps.begin(), ccTargetDeps.end());
|
|
++j;
|
|
|
|
for (; j != i->second.end(); ++j) {
|
|
std::vector<std::string> jDeps, depsIntersection;
|
|
this->AppendTargetDepends(*j, jDeps);
|
|
std::sort(jDeps.begin(), jDeps.end());
|
|
std::set_intersection(ccTargetDeps.begin(), ccTargetDeps.end(),
|
|
jDeps.begin(), jDeps.end(),
|
|
std::back_inserter(depsIntersection));
|
|
ccTargetDeps = depsIntersection;
|
|
}
|
|
|
|
this->WriteCustomCommandBuildStatement(i->first, ccTargetDeps);
|
|
}
|
|
}
|
|
|
|
std::string cmLocalNinjaGenerator::MakeCustomLauncher(
|
|
cmCustomCommandGenerator const& ccg)
|
|
{
|
|
const char* property = "RULE_LAUNCH_CUSTOM";
|
|
const char* property_value = this->Makefile->GetProperty(property);
|
|
|
|
if(!property_value || !*property_value)
|
|
{
|
|
return std::string();
|
|
}
|
|
|
|
// Expand rules in the empty string. It may insert the launcher and
|
|
// perform replacements.
|
|
RuleVariables vars;
|
|
vars.RuleLauncher = property;
|
|
std::string output;
|
|
const std::vector<std::string>& outputs = ccg.GetOutputs();
|
|
if(!outputs.empty())
|
|
{
|
|
RelativeRoot relative_root =
|
|
ccg.GetWorkingDirectory().empty() ? START_OUTPUT : NONE;
|
|
|
|
output = this->Convert(outputs[0], relative_root, SHELL);
|
|
}
|
|
vars.Output = output.c_str();
|
|
|
|
std::string launcher;
|
|
this->ExpandRuleVariables(launcher, vars);
|
|
if(!launcher.empty())
|
|
{
|
|
launcher += " ";
|
|
}
|
|
|
|
return launcher;
|
|
}
|