801 lines
27 KiB
C++
801 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 cmState::EXECUTABLE:
|
|
case cmState::SHARED_LIBRARY:
|
|
case cmState::STATIC_LIBRARY:
|
|
case cmState::MODULE_LIBRARY:
|
|
case cmState::OBJECT_LIBRARY:
|
|
return new cmNinjaNormalTargetGenerator(target);
|
|
|
|
case cmState::UTILITY:
|
|
return new cmNinjaUtilityTargetGenerator(target);;
|
|
|
|
case cmState::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.
|
|
if (strcmp(target->GetLocalGenerator()->GetCurrentSourceDirectory(),
|
|
target->GetLocalGenerator()->GetSourceDirectory()) == 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->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY ||
|
|
this->GeneratorTarget->GetType() == cmState::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->GeneratorTarget);
|
|
path += "/";
|
|
path += objectName;
|
|
return path;
|
|
}
|
|
|
|
std::string cmNinjaTargetGenerator::GetTargetOutputDir() const
|
|
{
|
|
std::string dir = this->GeneratorTarget->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->GeneratorTarget->GetType() == cmState::EXECUTABLE ||
|
|
this->GeneratorTarget->GetType() == cmState::STATIC_LIBRARY ||
|
|
this->GeneratorTarget->GetType() == cmState::SHARED_LIBRARY ||
|
|
this->GeneratorTarget->GetType() == cmState::MODULE_LIBRARY)
|
|
{
|
|
pdbPath = this->GeneratorTarget->GetPDBDirectory(this->GetConfigName());
|
|
pdbPath += "/";
|
|
pdbPath += this->GeneratorTarget->GetPDBName(this->GetConfigName());
|
|
}
|
|
if(this->GeneratorTarget->GetType() <= cmState::OBJECT_LIBRARY)
|
|
{
|
|
compilePdbPath =
|
|
this->GeneratorTarget->GetCompilePDBPath(this->GetConfigName());
|
|
if(compilePdbPath.empty())
|
|
{
|
|
compilePdbPath = this->GeneratorTarget->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 "
|
|
<< cmState::GetTargetTypeName(this->GetGeneratorTarget()->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->GeneratorTarget->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;
|
|
}
|
|
}
|