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.
802 lines
27 KiB
C++
802 lines
27 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 "cmNinjaTargetGenerator.h"
|
|
#include "cmGlobalNinjaGenerator.h"
|
|
#include "cmLocalNinjaGenerator.h"
|
|
#include "cmGeneratedFileStream.h"
|
|
#include "cmGeneratorTarget.h"
|
|
#include "cmNinjaNormalTargetGenerator.h"
|
|
#include "cmNinjaUtilityTargetGenerator.h"
|
|
#include "cmSystemTools.h"
|
|
#include "cmMakefile.h"
|
|
#include "cmComputeLinkInformation.h"
|
|
#include "cmSourceFile.h"
|
|
#include "cmCustomCommandGenerator.h"
|
|
#include "cmAlgorithms.h"
|
|
|
|
#include <algorithm>
|
|
|
|
cmNinjaTargetGenerator *
|
|
cmNinjaTargetGenerator::New(cmGeneratorTarget* target)
|
|
{
|
|
switch (target->GetType())
|
|
{
|
|
case cmTarget::EXECUTABLE:
|
|
case cmTarget::SHARED_LIBRARY:
|
|
case cmTarget::STATIC_LIBRARY:
|
|
case cmTarget::MODULE_LIBRARY:
|
|
case cmTarget::OBJECT_LIBRARY:
|
|
return new cmNinjaNormalTargetGenerator(target);
|
|
|
|
case cmTarget::UTILITY:
|
|
return new cmNinjaUtilityTargetGenerator(target);;
|
|
|
|
case cmTarget::GLOBAL_TARGET: {
|
|
// We only want to process global targets that live in the home
|
|
// (i.e. top-level) directory. CMake creates copies of these targets
|
|
// in every directory, which we don't need.
|
|
cmMakefile *mf = target->Target->GetMakefile();
|
|
if (strcmp(mf->GetCurrentSourceDirectory(),
|
|
mf->GetHomeDirectory()) == 0)
|
|
return new cmNinjaUtilityTargetGenerator(target);
|
|
// else fallthrough
|
|
}
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
cmNinjaTargetGenerator::cmNinjaTargetGenerator(cmGeneratorTarget* target)
|
|
: cmCommonTargetGenerator(cmOutputConverter::HOME_OUTPUT, target),
|
|
MacOSXContentGenerator(0),
|
|
OSXBundleGenerator(0),
|
|
MacContentFolders(),
|
|
LocalGenerator(
|
|
static_cast<cmLocalNinjaGenerator*>(target->GetLocalGenerator())),
|
|
Objects()
|
|
{
|
|
MacOSXContentGenerator = new MacOSXContentGeneratorType(this);
|
|
}
|
|
|
|
cmNinjaTargetGenerator::~cmNinjaTargetGenerator()
|
|
{
|
|
delete this->MacOSXContentGenerator;
|
|
}
|
|
|
|
cmGeneratedFileStream& cmNinjaTargetGenerator::GetBuildFileStream() const
|
|
{
|
|
return *this->GetGlobalGenerator()->GetBuildFileStream();
|
|
}
|
|
|
|
cmGeneratedFileStream& cmNinjaTargetGenerator::GetRulesFileStream() const
|
|
{
|
|
return *this->GetGlobalGenerator()->GetRulesFileStream();
|
|
}
|
|
|
|
cmGlobalNinjaGenerator* cmNinjaTargetGenerator::GetGlobalGenerator() const
|
|
{
|
|
return this->LocalGenerator->GetGlobalNinjaGenerator();
|
|
}
|
|
|
|
std::string cmNinjaTargetGenerator::LanguageCompilerRule(
|
|
const std::string& lang) const
|
|
{
|
|
return lang + "_COMPILER__" +
|
|
cmGlobalNinjaGenerator::EncodeRuleName(this->Target->GetName());
|
|
}
|
|
|
|
std::string
|
|
cmNinjaTargetGenerator::OrderDependsTargetForTarget()
|
|
{
|
|
return "cmake_order_depends_target_" + this->GetTargetName();
|
|
}
|
|
|
|
// TODO: Most of the code is picked up from
|
|
// void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink),
|
|
// void cmMakefileTargetGenerator::WriteTargetLanguageFlags()
|
|
// Refactor it.
|
|
std::string
|
|
cmNinjaTargetGenerator::ComputeFlagsForObject(cmSourceFile const* source,
|
|
const std::string& language)
|
|
{
|
|
std::string flags = this->GetFlags(language);
|
|
|
|
// Add Fortran format flags.
|
|
if(language == "Fortran")
|
|
{
|
|
this->AppendFortranFormatFlags(flags, *source);
|
|
}
|
|
|
|
// Add source file specific flags.
|
|
this->LocalGenerator->AppendFlags(flags,
|
|
source->GetProperty("COMPILE_FLAGS"));
|
|
|
|
return flags;
|
|
}
|
|
|
|
void cmNinjaTargetGenerator::AddIncludeFlags(std::string& languageFlags,
|
|
std::string const& language)
|
|
{
|
|
std::vector<std::string> includes;
|
|
this->LocalGenerator->GetIncludeDirectories(includes,
|
|
this->GeneratorTarget,
|
|
language,
|
|
this->GetConfigName());
|
|
// Add include directory flags.
|
|
std::string includeFlags =
|
|
this->LocalGenerator->GetIncludeFlags(includes, this->GeneratorTarget,
|
|
language,
|
|
language == "RC" ? true : false, // full include paths for RC
|
|
// needed by cmcldeps
|
|
false,
|
|
this->GetConfigName());
|
|
if (this->GetGlobalGenerator()->IsGCCOnWindows())
|
|
cmSystemTools::ReplaceString(includeFlags, "\\", "/");
|
|
|
|
this->LocalGenerator->AppendFlags(languageFlags, includeFlags);
|
|
}
|
|
|
|
bool cmNinjaTargetGenerator::NeedDepTypeMSVC(const std::string& lang) const
|
|
{
|
|
if (lang == "C" || lang == "CXX")
|
|
{
|
|
cmMakefile* mf = this->GetMakefile();
|
|
return (
|
|
strcmp(mf->GetSafeDefinition("CMAKE_C_COMPILER_ID"), "MSVC") == 0 ||
|
|
strcmp(mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID"), "MSVC") == 0 ||
|
|
strcmp(mf->GetSafeDefinition("CMAKE_C_SIMULATE_ID"), "MSVC") == 0 ||
|
|
strcmp(mf->GetSafeDefinition("CMAKE_CXX_SIMULATE_ID"), "MSVC") == 0
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// TODO: Refactor with
|
|
// void cmMakefileTargetGenerator::WriteTargetLanguageFlags().
|
|
std::string
|
|
cmNinjaTargetGenerator::
|
|
ComputeDefines(cmSourceFile const* source, const std::string& language)
|
|
{
|
|
std::set<std::string> defines;
|
|
this->LocalGenerator->AppendDefines
|
|
(defines,
|
|
source->GetProperty("COMPILE_DEFINITIONS"));
|
|
{
|
|
std::string defPropName = "COMPILE_DEFINITIONS_";
|
|
defPropName += cmSystemTools::UpperCase(this->GetConfigName());
|
|
this->LocalGenerator->AppendDefines
|
|
(defines,
|
|
source->GetProperty(defPropName));
|
|
}
|
|
|
|
std::string definesString = this->GetDefines(language);
|
|
this->LocalGenerator->JoinDefines(defines, definesString,
|
|
language);
|
|
|
|
return definesString;
|
|
}
|
|
|
|
cmNinjaDeps cmNinjaTargetGenerator::ComputeLinkDeps() const
|
|
{
|
|
// Static libraries never depend on other targets for linking.
|
|
if (this->Target->GetType() == cmTarget::STATIC_LIBRARY ||
|
|
this->Target->GetType() == cmTarget::OBJECT_LIBRARY)
|
|
return cmNinjaDeps();
|
|
|
|
cmComputeLinkInformation* cli =
|
|
this->GeneratorTarget->GetLinkInformation(this->GetConfigName());
|
|
if(!cli)
|
|
return cmNinjaDeps();
|
|
|
|
const std::vector<std::string> &deps = cli->GetDepends();
|
|
cmNinjaDeps result(deps.size());
|
|
std::transform(deps.begin(), deps.end(), result.begin(), MapToNinjaPath());
|
|
|
|
// Add a dependency on the link definitions file, if any.
|
|
if(!this->ModuleDefinitionFile.empty())
|
|
{
|
|
result.push_back(this->ConvertToNinjaPath(this->ModuleDefinitionFile));
|
|
}
|
|
|
|
// Add a dependency on user-specified manifest files, if any.
|
|
std::vector<cmSourceFile const*> manifest_srcs;
|
|
this->GeneratorTarget->GetManifests(manifest_srcs, this->ConfigName);
|
|
for (std::vector<cmSourceFile const*>::iterator mi = manifest_srcs.begin();
|
|
mi != manifest_srcs.end(); ++mi)
|
|
{
|
|
result.push_back(this->ConvertToNinjaPath((*mi)->GetFullPath()));
|
|
}
|
|
|
|
// Add user-specified dependencies.
|
|
if (const char* linkDepends = this->Target->GetProperty("LINK_DEPENDS"))
|
|
{
|
|
std::vector<std::string> linkDeps;
|
|
cmSystemTools::ExpandListArgument(linkDepends, linkDeps);
|
|
std::transform(linkDeps.begin(), linkDeps.end(),
|
|
std::back_inserter(result), MapToNinjaPath());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
std::string
|
|
cmNinjaTargetGenerator
|
|
::GetSourceFilePath(cmSourceFile const* source) const
|
|
{
|
|
return ConvertToNinjaPath(source->GetFullPath());
|
|
}
|
|
|
|
std::string
|
|
cmNinjaTargetGenerator
|
|
::GetObjectFilePath(cmSourceFile const* source) const
|
|
{
|
|
std::string path = this->LocalGenerator->GetHomeRelativeOutputPath();
|
|
if(!path.empty())
|
|
path += "/";
|
|
std::string const& objectName = this->GeneratorTarget
|
|
->GetObjectName(source);
|
|
path += this->LocalGenerator->GetTargetDirectory(*this->Target);
|
|
path += "/";
|
|
path += objectName;
|
|
return path;
|
|
}
|
|
|
|
std::string cmNinjaTargetGenerator::GetTargetOutputDir() const
|
|
{
|
|
std::string dir = this->Target->GetDirectory(this->GetConfigName());
|
|
return ConvertToNinjaPath(dir);
|
|
}
|
|
|
|
std::string
|
|
cmNinjaTargetGenerator
|
|
::GetTargetFilePath(const std::string& name) const
|
|
{
|
|
std::string path = this->GetTargetOutputDir();
|
|
if (path.empty() || path == ".")
|
|
return name;
|
|
path += "/";
|
|
path += name;
|
|
return path;
|
|
}
|
|
|
|
std::string cmNinjaTargetGenerator::GetTargetName() const
|
|
{
|
|
return this->Target->GetName();
|
|
}
|
|
|
|
|
|
bool cmNinjaTargetGenerator::SetMsvcTargetPdbVariable(cmNinjaVars& vars) const
|
|
{
|
|
cmMakefile* mf = this->GetMakefile();
|
|
if (mf->GetDefinition("MSVC_C_ARCHITECTURE_ID") ||
|
|
mf->GetDefinition("MSVC_CXX_ARCHITECTURE_ID"))
|
|
{
|
|
std::string pdbPath;
|
|
std::string compilePdbPath;
|
|
if(this->Target->GetType() == cmTarget::EXECUTABLE ||
|
|
this->Target->GetType() == cmTarget::STATIC_LIBRARY ||
|
|
this->Target->GetType() == cmTarget::SHARED_LIBRARY ||
|
|
this->Target->GetType() == cmTarget::MODULE_LIBRARY)
|
|
{
|
|
pdbPath = this->Target->GetPDBDirectory(this->GetConfigName());
|
|
pdbPath += "/";
|
|
pdbPath += this->GeneratorTarget->GetPDBName(this->GetConfigName());
|
|
}
|
|
if(this->Target->GetType() <= cmTarget::OBJECT_LIBRARY)
|
|
{
|
|
compilePdbPath =
|
|
this->GeneratorTarget->GetCompilePDBPath(this->GetConfigName());
|
|
if(compilePdbPath.empty())
|
|
{
|
|
compilePdbPath = this->Target->GetSupportDirectory() + "/";
|
|
}
|
|
}
|
|
|
|
vars["TARGET_PDB"] = this->GetLocalGenerator()->ConvertToOutputFormat(
|
|
ConvertToNinjaPath(pdbPath),
|
|
cmLocalGenerator::SHELL);
|
|
vars["TARGET_COMPILE_PDB"] =
|
|
this->GetLocalGenerator()->ConvertToOutputFormat(
|
|
ConvertToNinjaPath(compilePdbPath),
|
|
cmLocalGenerator::SHELL);
|
|
|
|
EnsureParentDirectoryExists(pdbPath);
|
|
EnsureParentDirectoryExists(compilePdbPath);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
cmNinjaTargetGenerator
|
|
::WriteLanguageRules(const std::string& language)
|
|
{
|
|
#ifdef NINJA_GEN_VERBOSE_FILES
|
|
this->GetRulesFileStream()
|
|
<< "# Rules for language " << language << "\n\n";
|
|
#endif
|
|
this->WriteCompileRule(language);
|
|
}
|
|
|
|
void
|
|
cmNinjaTargetGenerator
|
|
::WriteCompileRule(const std::string& lang)
|
|
{
|
|
cmLocalGenerator::RuleVariables vars;
|
|
vars.RuleLauncher = "RULE_LAUNCH_COMPILE";
|
|
vars.CMTarget = this->GetTarget();
|
|
vars.Language = lang.c_str();
|
|
vars.Source = "$in";
|
|
vars.Object = "$out";
|
|
vars.Defines = "$DEFINES";
|
|
vars.Includes = "$INCLUDES";
|
|
vars.TargetPDB = "$TARGET_PDB";
|
|
vars.TargetCompilePDB = "$TARGET_COMPILE_PDB";
|
|
vars.ObjectDir = "$OBJECT_DIR";
|
|
vars.ObjectFileDir = "$OBJECT_FILE_DIR";
|
|
|
|
cmMakefile* mf = this->GetMakefile();
|
|
|
|
// Tell ninja dependency format so all deps can be loaded into a database
|
|
std::string deptype;
|
|
std::string depfile;
|
|
std::string cldeps;
|
|
std::string flags = "$FLAGS";
|
|
if (this->NeedDepTypeMSVC(lang))
|
|
{
|
|
deptype = "msvc";
|
|
depfile = "";
|
|
flags += " /showIncludes";
|
|
}
|
|
else if (lang == "RC" && this->NeedDepTypeMSVC("C"))
|
|
{
|
|
// For the MS resource compiler we need cmcldeps, but skip dependencies
|
|
// for source-file try_compile cases because they are always fresh.
|
|
if (!mf->GetIsSourceFileTryCompile())
|
|
{
|
|
deptype = "gcc";
|
|
depfile = "$DEP_FILE";
|
|
const std::string cl = mf->GetDefinition("CMAKE_C_COMPILER") ?
|
|
mf->GetSafeDefinition("CMAKE_C_COMPILER") :
|
|
mf->GetSafeDefinition("CMAKE_CXX_COMPILER");
|
|
cldeps = "\"";
|
|
cldeps += cmSystemTools::GetCMClDepsCommand();
|
|
cldeps += "\" " + lang + " $in \"$DEP_FILE\" $out \"";
|
|
cldeps += mf->GetSafeDefinition("CMAKE_CL_SHOWINCLUDES_PREFIX");
|
|
cldeps += "\" \"" + cl + "\" ";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
deptype = "gcc";
|
|
const char* langdeptype = mf->GetDefinition("CMAKE_NINJA_DEPTYPE_" + lang);
|
|
if (langdeptype)
|
|
{
|
|
deptype = langdeptype;
|
|
}
|
|
depfile = "$DEP_FILE";
|
|
const std::string flagsName = "CMAKE_DEPFILE_FLAGS_" + lang;
|
|
std::string depfileFlags = mf->GetSafeDefinition(flagsName);
|
|
if (!depfileFlags.empty())
|
|
{
|
|
cmSystemTools::ReplaceString(depfileFlags, "<DEPFILE>", "$DEP_FILE");
|
|
cmSystemTools::ReplaceString(depfileFlags, "<OBJECT>", "$out");
|
|
cmSystemTools::ReplaceString(depfileFlags, "<CMAKE_C_COMPILER>",
|
|
mf->GetDefinition("CMAKE_C_COMPILER"));
|
|
flags += " " + depfileFlags;
|
|
}
|
|
}
|
|
|
|
vars.Flags = flags.c_str();
|
|
vars.DependencyFile = depfile.c_str();
|
|
|
|
// Rule for compiling object file.
|
|
const std::string cmdVar = std::string("CMAKE_") + lang + "_COMPILE_OBJECT";
|
|
std::string compileCmd = mf->GetRequiredDefinition(cmdVar);
|
|
std::vector<std::string> compileCmds;
|
|
cmSystemTools::ExpandListArgument(compileCmd, compileCmds);
|
|
|
|
// Maybe insert an include-what-you-use runner.
|
|
if (!compileCmds.empty() && (lang == "C" || lang == "CXX"))
|
|
{
|
|
std::string const iwyu_prop = lang + "_INCLUDE_WHAT_YOU_USE";
|
|
const char *iwyu = this->Target->GetProperty(iwyu_prop);
|
|
if (iwyu && *iwyu)
|
|
{
|
|
std::string run_iwyu =
|
|
this->GetLocalGenerator()->ConvertToOutputFormat(
|
|
cmSystemTools::GetCMakeCommand(), cmLocalGenerator::SHELL);
|
|
run_iwyu += " -E __run_iwyu --iwyu=";
|
|
run_iwyu += this->GetLocalGenerator()->EscapeForShell(iwyu);
|
|
run_iwyu += " -- ";
|
|
compileCmds.front().insert(0, run_iwyu);
|
|
}
|
|
}
|
|
|
|
// Maybe insert a compiler launcher like ccache or distcc
|
|
if (!compileCmds.empty() && (lang == "C" || lang == "CXX"))
|
|
{
|
|
std::string const clauncher_prop = lang + "_COMPILER_LAUNCHER";
|
|
const char *clauncher = this->Target->GetProperty(clauncher_prop);
|
|
if (clauncher && *clauncher)
|
|
{
|
|
std::vector<std::string> launcher_cmd;
|
|
cmSystemTools::ExpandListArgument(clauncher, launcher_cmd, true);
|
|
for (std::vector<std::string>::iterator i = launcher_cmd.begin(),
|
|
e = launcher_cmd.end(); i != e; ++i)
|
|
{
|
|
*i = this->LocalGenerator->EscapeForShell(*i);
|
|
}
|
|
std::string const& run_launcher = cmJoin(launcher_cmd, " ") + " ";
|
|
compileCmds.front().insert(0, run_launcher);
|
|
}
|
|
}
|
|
|
|
if (!compileCmds.empty())
|
|
{
|
|
compileCmds.front().insert(0, cldeps);
|
|
}
|
|
|
|
for (std::vector<std::string>::iterator i = compileCmds.begin();
|
|
i != compileCmds.end(); ++i)
|
|
this->GetLocalGenerator()->ExpandRuleVariables(*i, vars);
|
|
|
|
std::string cmdLine =
|
|
this->GetLocalGenerator()->BuildCommandLine(compileCmds);
|
|
|
|
|
|
// Write the rule for compiling file of the given language.
|
|
std::ostringstream comment;
|
|
comment << "Rule for compiling " << lang << " files.";
|
|
std::ostringstream description;
|
|
description << "Building " << lang << " object $out";
|
|
this->GetGlobalGenerator()->AddRule(this->LanguageCompilerRule(lang),
|
|
cmdLine,
|
|
description.str(),
|
|
comment.str(),
|
|
depfile,
|
|
deptype,
|
|
/*rspfile*/ "",
|
|
/*rspcontent*/ "",
|
|
/*restat*/ "",
|
|
/*generator*/ false);
|
|
}
|
|
|
|
void
|
|
cmNinjaTargetGenerator
|
|
::WriteObjectBuildStatements()
|
|
{
|
|
// Write comments.
|
|
cmGlobalNinjaGenerator::WriteDivider(this->GetBuildFileStream());
|
|
this->GetBuildFileStream()
|
|
<< "# Object build statements for "
|
|
<< cmTarget::GetTargetTypeName(this->GetTarget()->GetType())
|
|
<< " target "
|
|
<< this->GetTargetName()
|
|
<< "\n\n";
|
|
|
|
std::string config = this->Makefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
|
|
std::vector<cmSourceFile const*> customCommands;
|
|
this->GeneratorTarget->GetCustomCommands(customCommands, config);
|
|
for(std::vector<cmSourceFile const*>::const_iterator
|
|
si = customCommands.begin();
|
|
si != customCommands.end(); ++si)
|
|
{
|
|
cmCustomCommand const* cc = (*si)->GetCustomCommand();
|
|
this->GetLocalGenerator()->AddCustomCommandTarget(cc, this->GetTarget());
|
|
// Record the custom commands for this target. The container is used
|
|
// in WriteObjectBuildStatement when called in a loop below.
|
|
this->CustomCommands.push_back(cc);
|
|
}
|
|
std::vector<cmSourceFile const*> headerSources;
|
|
this->GeneratorTarget->GetHeaderSources(headerSources, config);
|
|
this->OSXBundleGenerator->GenerateMacOSXContentStatements(
|
|
headerSources,
|
|
this->MacOSXContentGenerator);
|
|
std::vector<cmSourceFile const*> extraSources;
|
|
this->GeneratorTarget->GetExtraSources(extraSources, config);
|
|
this->OSXBundleGenerator->GenerateMacOSXContentStatements(
|
|
extraSources,
|
|
this->MacOSXContentGenerator);
|
|
std::vector<cmSourceFile const*> externalObjects;
|
|
this->GeneratorTarget->GetExternalObjects(externalObjects, config);
|
|
for(std::vector<cmSourceFile const*>::const_iterator
|
|
si = externalObjects.begin();
|
|
si != externalObjects.end(); ++si)
|
|
{
|
|
this->Objects.push_back(this->GetSourceFilePath(*si));
|
|
}
|
|
|
|
cmNinjaDeps orderOnlyDeps;
|
|
this->GetLocalGenerator()->AppendTargetDepends(this->Target, orderOnlyDeps);
|
|
|
|
// Add order-only dependencies on custom command outputs.
|
|
for(std::vector<cmCustomCommand const*>::const_iterator
|
|
cci = this->CustomCommands.begin();
|
|
cci != this->CustomCommands.end(); ++cci)
|
|
{
|
|
cmCustomCommand const* cc = *cci;
|
|
cmCustomCommandGenerator ccg(*cc, this->GetConfigName(),
|
|
this->GetLocalGenerator());
|
|
const std::vector<std::string>& ccoutputs = ccg.GetOutputs();
|
|
const std::vector<std::string>& ccbyproducts= ccg.GetByproducts();
|
|
std::transform(ccoutputs.begin(), ccoutputs.end(),
|
|
std::back_inserter(orderOnlyDeps), MapToNinjaPath());
|
|
std::transform(ccbyproducts.begin(), ccbyproducts.end(),
|
|
std::back_inserter(orderOnlyDeps), MapToNinjaPath());
|
|
}
|
|
|
|
if (!orderOnlyDeps.empty())
|
|
{
|
|
cmNinjaDeps orderOnlyTarget;
|
|
orderOnlyTarget.push_back(this->OrderDependsTargetForTarget());
|
|
this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
|
|
"Order-only phony target for "
|
|
+ this->GetTargetName(),
|
|
orderOnlyTarget,
|
|
cmNinjaDeps(),
|
|
cmNinjaDeps(),
|
|
orderOnlyDeps);
|
|
}
|
|
std::vector<cmSourceFile const*> objectSources;
|
|
this->GeneratorTarget->GetObjectSources(objectSources, config);
|
|
for(std::vector<cmSourceFile const*>::const_iterator
|
|
si = objectSources.begin(); si != objectSources.end(); ++si)
|
|
{
|
|
this->WriteObjectBuildStatement(*si, !orderOnlyDeps.empty());
|
|
}
|
|
|
|
this->GetBuildFileStream() << "\n";
|
|
}
|
|
|
|
void
|
|
cmNinjaTargetGenerator
|
|
::WriteObjectBuildStatement(
|
|
cmSourceFile const* source, bool writeOrderDependsTargetForTarget)
|
|
{
|
|
std::string const language = source->GetLanguage();
|
|
std::string const sourceFileName =
|
|
language=="RC" ? source->GetFullPath() : this->GetSourceFilePath(source);
|
|
std::string const objectDir = this->Target->GetSupportDirectory();
|
|
std::string const objectFileName = this->GetObjectFilePath(source);
|
|
std::string const objectFileDir =
|
|
cmSystemTools::GetFilenamePath(objectFileName);
|
|
|
|
cmNinjaVars vars;
|
|
vars["FLAGS"] = this->ComputeFlagsForObject(source, language);
|
|
vars["DEFINES"] = this->ComputeDefines(source, language);
|
|
vars["INCLUDES"] = this->GetIncludes(language);
|
|
if (!this->NeedDepTypeMSVC(language))
|
|
{
|
|
vars["DEP_FILE"] =
|
|
cmGlobalNinjaGenerator::EncodeDepfileSpace(objectFileName + ".d");
|
|
}
|
|
|
|
this->ExportObjectCompileCommand(
|
|
language, sourceFileName,
|
|
objectDir, objectFileName, objectFileDir,
|
|
vars["FLAGS"], vars["DEFINES"], vars["INCLUDES"]
|
|
);
|
|
|
|
std::string comment;
|
|
std::string rule = this->LanguageCompilerRule(language);
|
|
|
|
cmNinjaDeps outputs;
|
|
outputs.push_back(objectFileName);
|
|
// Add this object to the list of object files.
|
|
this->Objects.push_back(objectFileName);
|
|
|
|
cmNinjaDeps explicitDeps;
|
|
explicitDeps.push_back(sourceFileName);
|
|
|
|
cmNinjaDeps implicitDeps;
|
|
if(const char* objectDeps = source->GetProperty("OBJECT_DEPENDS")) {
|
|
std::vector<std::string> depList;
|
|
cmSystemTools::ExpandListArgument(objectDeps, depList);
|
|
for(std::vector<std::string>::iterator odi = depList.begin();
|
|
odi != depList.end(); ++odi)
|
|
{
|
|
if (cmSystemTools::FileIsFullPath(*odi))
|
|
{
|
|
*odi = cmSystemTools::CollapseFullPath(*odi);
|
|
}
|
|
}
|
|
std::transform(depList.begin(), depList.end(),
|
|
std::back_inserter(implicitDeps), MapToNinjaPath());
|
|
}
|
|
|
|
cmNinjaDeps orderOnlyDeps;
|
|
if (writeOrderDependsTargetForTarget)
|
|
{
|
|
orderOnlyDeps.push_back(this->OrderDependsTargetForTarget());
|
|
}
|
|
|
|
// If the source file is GENERATED and does not have a custom command
|
|
// (either attached to this source file or another one), assume that one of
|
|
// the target dependencies, OBJECT_DEPENDS or header file custom commands
|
|
// will rebuild the file.
|
|
if (source->GetPropertyAsBool("GENERATED") && !source->GetCustomCommand() &&
|
|
!this->GetGlobalGenerator()->HasCustomCommandOutput(sourceFileName)) {
|
|
this->GetGlobalGenerator()->AddAssumedSourceDependencies(sourceFileName,
|
|
orderOnlyDeps);
|
|
}
|
|
|
|
EnsureParentDirectoryExists(objectFileName);
|
|
|
|
vars["OBJECT_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
|
|
ConvertToNinjaPath(objectDir),
|
|
cmLocalGenerator::SHELL);
|
|
vars["OBJECT_FILE_DIR"] = this->GetLocalGenerator()->ConvertToOutputFormat(
|
|
ConvertToNinjaPath(objectFileDir),
|
|
cmLocalGenerator::SHELL);
|
|
|
|
this->addPoolNinjaVariable("JOB_POOL_COMPILE", this->GetTarget(), vars);
|
|
|
|
this->SetMsvcTargetPdbVariable(vars);
|
|
|
|
this->GetGlobalGenerator()->WriteBuild(this->GetBuildFileStream(),
|
|
comment,
|
|
rule,
|
|
outputs,
|
|
explicitDeps,
|
|
implicitDeps,
|
|
orderOnlyDeps,
|
|
vars);
|
|
|
|
if(const char* objectOutputs = source->GetProperty("OBJECT_OUTPUTS")) {
|
|
std::vector<std::string> outputList;
|
|
cmSystemTools::ExpandListArgument(objectOutputs, outputList);
|
|
std::transform(outputList.begin(), outputList.end(), outputList.begin(),
|
|
MapToNinjaPath());
|
|
this->GetGlobalGenerator()->WritePhonyBuild(this->GetBuildFileStream(),
|
|
"Additional output files.",
|
|
outputList,
|
|
outputs);
|
|
}
|
|
}
|
|
|
|
void
|
|
cmNinjaTargetGenerator
|
|
::ExportObjectCompileCommand(
|
|
std::string const& language,
|
|
std::string const& sourceFileName,
|
|
std::string const& objectDir,
|
|
std::string const& objectFileName,
|
|
std::string const& objectFileDir,
|
|
std::string const& flags,
|
|
std::string const& defines,
|
|
std::string const& includes
|
|
)
|
|
{
|
|
if(!this->Makefile->IsOn("CMAKE_EXPORT_COMPILE_COMMANDS"))
|
|
{
|
|
return;
|
|
}
|
|
|
|
cmLocalGenerator::RuleVariables compileObjectVars;
|
|
compileObjectVars.Language = language.c_str();
|
|
|
|
std::string escapedSourceFileName = sourceFileName;
|
|
|
|
if (!cmSystemTools::FileIsFullPath(sourceFileName.c_str()))
|
|
{
|
|
escapedSourceFileName = cmSystemTools::CollapseFullPath(
|
|
escapedSourceFileName,
|
|
this->GetGlobalGenerator()->GetCMakeInstance()->
|
|
GetHomeOutputDirectory());
|
|
}
|
|
|
|
escapedSourceFileName =
|
|
this->LocalGenerator->ConvertToOutputFormat(
|
|
escapedSourceFileName, cmLocalGenerator::SHELL);
|
|
|
|
compileObjectVars.Source = escapedSourceFileName.c_str();
|
|
compileObjectVars.Object = objectFileName.c_str();
|
|
compileObjectVars.ObjectDir = objectDir.c_str();
|
|
compileObjectVars.ObjectFileDir = objectFileDir.c_str();
|
|
compileObjectVars.Flags = flags.c_str();
|
|
compileObjectVars.Defines = defines.c_str();
|
|
compileObjectVars.Includes = includes.c_str();
|
|
|
|
// Rule for compiling object file.
|
|
std::string compileCmdVar = "CMAKE_";
|
|
compileCmdVar += language;
|
|
compileCmdVar += "_COMPILE_OBJECT";
|
|
std::string compileCmd =
|
|
this->GetMakefile()->GetRequiredDefinition(compileCmdVar);
|
|
std::vector<std::string> compileCmds;
|
|
cmSystemTools::ExpandListArgument(compileCmd, compileCmds);
|
|
|
|
for (std::vector<std::string>::iterator i = compileCmds.begin();
|
|
i != compileCmds.end(); ++i)
|
|
this->GetLocalGenerator()->ExpandRuleVariables(*i, compileObjectVars);
|
|
|
|
std::string cmdLine =
|
|
this->GetLocalGenerator()->BuildCommandLine(compileCmds);
|
|
|
|
this->GetGlobalGenerator()->AddCXXCompileCommand(cmdLine,
|
|
sourceFileName);
|
|
}
|
|
|
|
void
|
|
cmNinjaTargetGenerator
|
|
::EnsureDirectoryExists(const std::string& path) const
|
|
{
|
|
if (cmSystemTools::FileIsFullPath(path.c_str()))
|
|
{
|
|
cmSystemTools::MakeDirectory(path.c_str());
|
|
}
|
|
else
|
|
{
|
|
const std::string fullPath = std::string(this->GetGlobalGenerator()->
|
|
GetCMakeInstance()->GetHomeOutputDirectory())
|
|
+ "/" + path;
|
|
cmSystemTools::MakeDirectory(fullPath.c_str());
|
|
}
|
|
}
|
|
|
|
void
|
|
cmNinjaTargetGenerator
|
|
::EnsureParentDirectoryExists(const std::string& path) const
|
|
{
|
|
EnsureDirectoryExists(cmSystemTools::GetParentDirectory(path));
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
void
|
|
cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()(
|
|
cmSourceFile const& source, const char* pkgloc)
|
|
{
|
|
// Skip OS X content when not building a Framework or Bundle.
|
|
if(!this->Generator->GetGeneratorTarget()->IsBundleOnApple())
|
|
{
|
|
return;
|
|
}
|
|
|
|
std::string macdir =
|
|
this->Generator->OSXBundleGenerator->InitMacOSXContentDirectory(pkgloc);
|
|
|
|
// Get the input file location.
|
|
std::string input = source.GetFullPath();
|
|
input =
|
|
this->Generator->GetGlobalGenerator()->ConvertToNinjaPath(input);
|
|
|
|
// Get the output file location.
|
|
std::string output = macdir;
|
|
output += "/";
|
|
output += cmSystemTools::GetFilenameName(input);
|
|
output =
|
|
this->Generator->GetGlobalGenerator()->ConvertToNinjaPath(output);
|
|
|
|
// Write a build statement to copy the content into the bundle.
|
|
this->Generator->GetGlobalGenerator()->WriteMacOSXContentBuild(input,
|
|
output);
|
|
|
|
// Add as a dependency of all target so that it gets called.
|
|
this->Generator->GetGlobalGenerator()->AddDependencyToAll(output);
|
|
}
|
|
|
|
void cmNinjaTargetGenerator::addPoolNinjaVariable(
|
|
const std::string& pool_property,
|
|
cmTarget* target,
|
|
cmNinjaVars& vars)
|
|
{
|
|
const char* pool = target->GetProperty(pool_property);
|
|
if (pool)
|
|
{
|
|
vars["pool"] = pool;
|
|
}
|
|
}
|