You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2730 lines
92 KiB
2730 lines
92 KiB
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
#include "cmLocalGenerator.h"
|
|
|
|
#include "cmAlgorithms.h"
|
|
#include "cmComputeLinkInformation.h"
|
|
#include "cmCustomCommandGenerator.h"
|
|
#include "cmGeneratedFileStream.h"
|
|
#include "cmGeneratorExpressionEvaluationFile.h"
|
|
#include "cmGeneratorTarget.h"
|
|
#include "cmGlobalGenerator.h"
|
|
#include "cmInstallGenerator.h"
|
|
#include "cmInstallScriptGenerator.h"
|
|
#include "cmInstallTargetGenerator.h"
|
|
#include "cmLinkLineComputer.h"
|
|
#include "cmMakefile.h"
|
|
#include "cmRulePlaceholderExpander.h"
|
|
#include "cmSourceFile.h"
|
|
#include "cmSourceFileLocation.h"
|
|
#include "cmState.h"
|
|
#include "cmStateDirectory.h"
|
|
#include "cmStateTypes.h"
|
|
#include "cmSystemTools.h"
|
|
#include "cmTarget.h"
|
|
#include "cmTestGenerator.h"
|
|
#include "cmVersion.h"
|
|
#include "cmake.h"
|
|
|
|
#if defined(CMAKE_BUILD_WITH_CMAKE)
|
|
# define CM_LG_ENCODE_OBJECT_NAMES
|
|
# include "cmCryptoHash.h"
|
|
#endif
|
|
|
|
#include "cmsys/RegularExpression.hxx"
|
|
#include <algorithm>
|
|
#include <assert.h>
|
|
#include <iterator>
|
|
#include <sstream>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <unordered_set>
|
|
#include <utility>
|
|
|
|
#if defined(__HAIKU__)
|
|
# include <FindDirectory.h>
|
|
# include <StorageDefs.h>
|
|
#endif
|
|
|
|
// List of variables that are replaced when
|
|
// rules are expanced. These variables are
|
|
// replaced in the form <var> with GetSafeDefinition(var).
|
|
// ${LANG} is replaced in the variable first with all enabled
|
|
// languages.
|
|
static const char* ruleReplaceVars[] = {
|
|
"CMAKE_${LANG}_COMPILER",
|
|
"CMAKE_SHARED_LIBRARY_CREATE_${LANG}_FLAGS",
|
|
"CMAKE_SHARED_MODULE_CREATE_${LANG}_FLAGS",
|
|
"CMAKE_SHARED_MODULE_${LANG}_FLAGS",
|
|
"CMAKE_SHARED_LIBRARY_${LANG}_FLAGS",
|
|
"CMAKE_${LANG}_LINK_FLAGS",
|
|
"CMAKE_SHARED_LIBRARY_SONAME_${LANG}_FLAG",
|
|
"CMAKE_${LANG}_ARCHIVE",
|
|
"CMAKE_AR",
|
|
"CMAKE_CURRENT_SOURCE_DIR",
|
|
"CMAKE_CURRENT_BINARY_DIR",
|
|
"CMAKE_RANLIB",
|
|
"CMAKE_LINKER",
|
|
"CMAKE_CUDA_HOST_COMPILER",
|
|
"CMAKE_CUDA_HOST_LINK_LAUNCHER",
|
|
"CMAKE_CL_SHOWINCLUDES_PREFIX"
|
|
};
|
|
|
|
cmLocalGenerator::cmLocalGenerator(cmGlobalGenerator* gg, cmMakefile* makefile)
|
|
: cmOutputConverter(makefile->GetStateSnapshot())
|
|
, StateSnapshot(makefile->GetStateSnapshot())
|
|
, DirectoryBacktrace(makefile->GetBacktrace())
|
|
{
|
|
this->GlobalGenerator = gg;
|
|
|
|
this->Makefile = makefile;
|
|
|
|
this->AliasTargets = makefile->GetAliasTargets();
|
|
|
|
this->EmitUniversalBinaryFlags = true;
|
|
this->BackwardsCompatibility = 0;
|
|
this->BackwardsCompatibilityFinal = false;
|
|
|
|
this->ComputeObjectMaxPath();
|
|
|
|
std::vector<std::string> enabledLanguages =
|
|
this->GetState()->GetEnabledLanguages();
|
|
|
|
if (const char* sysrootCompile =
|
|
this->Makefile->GetDefinition("CMAKE_SYSROOT_COMPILE")) {
|
|
this->CompilerSysroot = sysrootCompile;
|
|
} else {
|
|
this->CompilerSysroot = this->Makefile->GetSafeDefinition("CMAKE_SYSROOT");
|
|
}
|
|
|
|
if (const char* sysrootLink =
|
|
this->Makefile->GetDefinition("CMAKE_SYSROOT_LINK")) {
|
|
this->LinkerSysroot = sysrootLink;
|
|
} else {
|
|
this->LinkerSysroot = this->Makefile->GetSafeDefinition("CMAKE_SYSROOT");
|
|
}
|
|
|
|
for (std::string const& lang : enabledLanguages) {
|
|
if (lang == "NONE") {
|
|
continue;
|
|
}
|
|
this->Compilers["CMAKE_" + lang + "_COMPILER"] = lang;
|
|
|
|
this->VariableMappings["CMAKE_" + lang + "_COMPILER"] =
|
|
this->Makefile->GetSafeDefinition("CMAKE_" + lang + "_COMPILER");
|
|
|
|
std::string const& compilerArg1 = "CMAKE_" + lang + "_COMPILER_ARG1";
|
|
std::string const& compilerTarget = "CMAKE_" + lang + "_COMPILER_TARGET";
|
|
std::string const& compilerOptionTarget =
|
|
"CMAKE_" + lang + "_COMPILE_OPTIONS_TARGET";
|
|
std::string const& compilerExternalToolchain =
|
|
"CMAKE_" + lang + "_COMPILER_EXTERNAL_TOOLCHAIN";
|
|
std::string const& compilerOptionExternalToolchain =
|
|
"CMAKE_" + lang + "_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN";
|
|
std::string const& compilerOptionSysroot =
|
|
"CMAKE_" + lang + "_COMPILE_OPTIONS_SYSROOT";
|
|
|
|
this->VariableMappings[compilerArg1] =
|
|
this->Makefile->GetSafeDefinition(compilerArg1);
|
|
this->VariableMappings[compilerTarget] =
|
|
this->Makefile->GetSafeDefinition(compilerTarget);
|
|
this->VariableMappings[compilerOptionTarget] =
|
|
this->Makefile->GetSafeDefinition(compilerOptionTarget);
|
|
this->VariableMappings[compilerExternalToolchain] =
|
|
this->Makefile->GetSafeDefinition(compilerExternalToolchain);
|
|
this->VariableMappings[compilerOptionExternalToolchain] =
|
|
this->Makefile->GetSafeDefinition(compilerOptionExternalToolchain);
|
|
this->VariableMappings[compilerOptionSysroot] =
|
|
this->Makefile->GetSafeDefinition(compilerOptionSysroot);
|
|
|
|
for (const char* const* replaceIter = cm::cbegin(ruleReplaceVars);
|
|
replaceIter != cm::cend(ruleReplaceVars); ++replaceIter) {
|
|
std::string actualReplace = *replaceIter;
|
|
if (actualReplace.find("${LANG}") != std::string::npos) {
|
|
cmSystemTools::ReplaceString(actualReplace, "${LANG}", lang);
|
|
}
|
|
|
|
this->VariableMappings[actualReplace] =
|
|
this->Makefile->GetSafeDefinition(actualReplace);
|
|
}
|
|
}
|
|
}
|
|
|
|
cmRulePlaceholderExpander* cmLocalGenerator::CreateRulePlaceholderExpander()
|
|
const
|
|
{
|
|
return new cmRulePlaceholderExpander(this->Compilers, this->VariableMappings,
|
|
this->CompilerSysroot,
|
|
this->LinkerSysroot);
|
|
}
|
|
|
|
cmLocalGenerator::~cmLocalGenerator()
|
|
{
|
|
cmDeleteAll(this->GeneratorTargets);
|
|
cmDeleteAll(this->OwnedImportedGeneratorTargets);
|
|
}
|
|
|
|
void cmLocalGenerator::IssueMessage(cmake::MessageType t,
|
|
std::string const& text) const
|
|
{
|
|
this->GetCMakeInstance()->IssueMessage(t, text, this->DirectoryBacktrace);
|
|
}
|
|
|
|
void cmLocalGenerator::ComputeObjectMaxPath()
|
|
{
|
|
// Choose a maximum object file name length.
|
|
#if defined(_WIN32) || defined(__CYGWIN__)
|
|
this->ObjectPathMax = 250;
|
|
#else
|
|
this->ObjectPathMax = 1000;
|
|
#endif
|
|
const char* plen = this->Makefile->GetDefinition("CMAKE_OBJECT_PATH_MAX");
|
|
if (plen && *plen) {
|
|
unsigned int pmax;
|
|
if (sscanf(plen, "%u", &pmax) == 1) {
|
|
if (pmax >= 128) {
|
|
this->ObjectPathMax = pmax;
|
|
} else {
|
|
std::ostringstream w;
|
|
w << "CMAKE_OBJECT_PATH_MAX is set to " << pmax
|
|
<< ", which is less than the minimum of 128. "
|
|
<< "The value will be ignored.";
|
|
this->IssueMessage(cmake::AUTHOR_WARNING, w.str());
|
|
}
|
|
} else {
|
|
std::ostringstream w;
|
|
w << "CMAKE_OBJECT_PATH_MAX is set to \"" << plen
|
|
<< "\", which fails to parse as a positive integer. "
|
|
<< "The value will be ignored.";
|
|
this->IssueMessage(cmake::AUTHOR_WARNING, w.str());
|
|
}
|
|
}
|
|
this->ObjectMaxPathViolations.clear();
|
|
}
|
|
|
|
void cmLocalGenerator::MoveSystemIncludesToEnd(
|
|
std::vector<std::string>& includeDirs, const std::string& config,
|
|
const std::string& lang, const cmGeneratorTarget* target) const
|
|
{
|
|
if (!target) {
|
|
return;
|
|
}
|
|
|
|
std::stable_sort(
|
|
includeDirs.begin(), includeDirs.end(),
|
|
[&target, &config, &lang](std::string const& a, std::string const& b) {
|
|
return !target->IsSystemIncludeDirectory(a, config, lang) &&
|
|
target->IsSystemIncludeDirectory(b, config, lang);
|
|
});
|
|
}
|
|
|
|
void cmLocalGenerator::TraceDependencies()
|
|
{
|
|
std::vector<std::string> configs;
|
|
this->Makefile->GetConfigurations(configs);
|
|
if (configs.empty()) {
|
|
configs.emplace_back();
|
|
}
|
|
for (std::string const& c : configs) {
|
|
this->GlobalGenerator->CreateEvaluationSourceFiles(c);
|
|
}
|
|
// Generate the rule files for each target.
|
|
const std::vector<cmGeneratorTarget*>& targets = this->GetGeneratorTargets();
|
|
for (cmGeneratorTarget* target : targets) {
|
|
if (target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
|
|
continue;
|
|
}
|
|
target->TraceDependencies();
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::GenerateTestFiles()
|
|
{
|
|
if (!this->Makefile->IsOn("CMAKE_TESTING_ENABLED")) {
|
|
return;
|
|
}
|
|
|
|
// Compute the set of configurations.
|
|
std::vector<std::string> configurationTypes;
|
|
const std::string& config =
|
|
this->Makefile->GetConfigurations(configurationTypes, false);
|
|
|
|
std::string file = this->StateSnapshot.GetDirectory().GetCurrentBinary();
|
|
file += "/";
|
|
file += "CTestTestfile.cmake";
|
|
|
|
cmGeneratedFileStream fout(file);
|
|
fout.SetCopyIfDifferent(true);
|
|
|
|
fout << "# CMake generated Testfile for " << std::endl
|
|
<< "# Source directory: "
|
|
<< this->StateSnapshot.GetDirectory().GetCurrentSource() << std::endl
|
|
<< "# Build directory: "
|
|
<< this->StateSnapshot.GetDirectory().GetCurrentBinary() << std::endl
|
|
<< "# " << std::endl
|
|
<< "# This file includes the relevant testing commands "
|
|
<< "required for " << std::endl
|
|
<< "# testing this directory and lists subdirectories to "
|
|
<< "be tested as well." << std::endl;
|
|
|
|
const char* testIncludeFile =
|
|
this->Makefile->GetProperty("TEST_INCLUDE_FILE");
|
|
if (testIncludeFile) {
|
|
fout << "include(\"" << testIncludeFile << "\")" << std::endl;
|
|
}
|
|
|
|
const char* testIncludeFiles =
|
|
this->Makefile->GetProperty("TEST_INCLUDE_FILES");
|
|
if (testIncludeFiles) {
|
|
std::vector<std::string> includesList;
|
|
cmSystemTools::ExpandListArgument(testIncludeFiles, includesList);
|
|
for (std::string const& i : includesList) {
|
|
fout << "include(\"" << i << "\")" << std::endl;
|
|
}
|
|
}
|
|
|
|
// Ask each test generator to write its code.
|
|
std::vector<cmTestGenerator*> const& testers =
|
|
this->Makefile->GetTestGenerators();
|
|
for (cmTestGenerator* tester : testers) {
|
|
tester->Compute(this);
|
|
tester->Generate(fout, config, configurationTypes);
|
|
}
|
|
typedef std::vector<cmStateSnapshot> vec_t;
|
|
vec_t const& children = this->Makefile->GetStateSnapshot().GetChildren();
|
|
std::string parentBinDir = this->GetCurrentBinaryDirectory();
|
|
for (cmStateSnapshot const& i : children) {
|
|
// TODO: Use add_subdirectory instead?
|
|
std::string outP = i.GetDirectory().GetCurrentBinary();
|
|
outP = this->ConvertToRelativePath(parentBinDir, outP);
|
|
outP = cmOutputConverter::EscapeForCMake(outP);
|
|
fout << "subdirs(" << outP << ")" << std::endl;
|
|
}
|
|
|
|
// Add directory labels property
|
|
const char* directoryLabels =
|
|
this->Makefile->GetDefinition("CMAKE_DIRECTORY_LABELS");
|
|
const char* labels = this->Makefile->GetProperty("LABELS");
|
|
|
|
if (labels || directoryLabels) {
|
|
fout << "set_directory_properties(PROPERTIES LABELS ";
|
|
if (labels) {
|
|
fout << cmOutputConverter::EscapeForCMake(labels);
|
|
}
|
|
if (labels && directoryLabels) {
|
|
fout << ";";
|
|
}
|
|
if (directoryLabels) {
|
|
fout << cmOutputConverter::EscapeForCMake(directoryLabels);
|
|
}
|
|
fout << ")" << std::endl;
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::CreateEvaluationFileOutputs(std::string const& config)
|
|
{
|
|
std::vector<cmGeneratorExpressionEvaluationFile*> ef =
|
|
this->Makefile->GetEvaluationFiles();
|
|
for (cmGeneratorExpressionEvaluationFile* geef : ef) {
|
|
geef->CreateOutputFile(this, config);
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::ProcessEvaluationFiles(
|
|
std::vector<std::string>& generatedFiles)
|
|
{
|
|
std::vector<cmGeneratorExpressionEvaluationFile*> ef =
|
|
this->Makefile->GetEvaluationFiles();
|
|
for (cmGeneratorExpressionEvaluationFile* geef : ef) {
|
|
geef->Generate(this);
|
|
if (cmSystemTools::GetFatalErrorOccured()) {
|
|
return;
|
|
}
|
|
std::vector<std::string> files = geef->GetFiles();
|
|
std::sort(files.begin(), files.end());
|
|
|
|
std::vector<std::string> intersection;
|
|
std::set_intersection(files.begin(), files.end(), generatedFiles.begin(),
|
|
generatedFiles.end(),
|
|
std::back_inserter(intersection));
|
|
if (!intersection.empty()) {
|
|
cmSystemTools::Error("Files to be generated by multiple different "
|
|
"commands: ",
|
|
cmWrap('"', intersection, '"', " ").c_str());
|
|
return;
|
|
}
|
|
|
|
generatedFiles.insert(generatedFiles.end(), files.begin(), files.end());
|
|
std::vector<std::string>::iterator newIt =
|
|
generatedFiles.end() - files.size();
|
|
std::inplace_merge(generatedFiles.begin(), newIt, generatedFiles.end());
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::GenerateInstallRules()
|
|
{
|
|
// Compute the install prefix.
|
|
const char* prefix = this->Makefile->GetDefinition("CMAKE_INSTALL_PREFIX");
|
|
|
|
#if defined(_WIN32) && !defined(__CYGWIN__)
|
|
std::string prefix_win32;
|
|
if (!prefix) {
|
|
if (!cmSystemTools::GetEnv("SystemDrive", prefix_win32)) {
|
|
prefix_win32 = "C:";
|
|
}
|
|
const char* project_name = this->Makefile->GetDefinition("PROJECT_NAME");
|
|
if (project_name && project_name[0]) {
|
|
prefix_win32 += "/Program Files/";
|
|
prefix_win32 += project_name;
|
|
} else {
|
|
prefix_win32 += "/InstalledCMakeProject";
|
|
}
|
|
prefix = prefix_win32.c_str();
|
|
}
|
|
#elif defined(__HAIKU__)
|
|
char dir[B_PATH_NAME_LENGTH];
|
|
if (!prefix) {
|
|
if (find_directory(B_SYSTEM_DIRECTORY, -1, false, dir, sizeof(dir)) ==
|
|
B_OK) {
|
|
prefix = dir;
|
|
} else {
|
|
prefix = "/boot/system";
|
|
}
|
|
}
|
|
#else
|
|
if (!prefix) {
|
|
prefix = "/usr/local";
|
|
}
|
|
#endif
|
|
if (const char* stagingPrefix =
|
|
this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX")) {
|
|
prefix = stagingPrefix;
|
|
}
|
|
|
|
// Compute the set of configurations.
|
|
std::vector<std::string> configurationTypes;
|
|
const std::string& config =
|
|
this->Makefile->GetConfigurations(configurationTypes, false);
|
|
|
|
// Choose a default install configuration.
|
|
std::string default_config = config;
|
|
const char* default_order[] = { "RELEASE", "MINSIZEREL", "RELWITHDEBINFO",
|
|
"DEBUG", nullptr };
|
|
for (const char** c = default_order; *c && default_config.empty(); ++c) {
|
|
for (std::string const& configurationType : configurationTypes) {
|
|
if (cmSystemTools::UpperCase(configurationType) == *c) {
|
|
default_config = configurationType;
|
|
}
|
|
}
|
|
}
|
|
if (default_config.empty() && !configurationTypes.empty()) {
|
|
default_config = configurationTypes[0];
|
|
}
|
|
|
|
// Create the install script file.
|
|
std::string file = this->StateSnapshot.GetDirectory().GetCurrentBinary();
|
|
std::string homedir = this->GetState()->GetBinaryDirectory();
|
|
int toplevel_install = 0;
|
|
if (file == homedir) {
|
|
toplevel_install = 1;
|
|
}
|
|
file += "/cmake_install.cmake";
|
|
cmGeneratedFileStream fout(file);
|
|
fout.SetCopyIfDifferent(true);
|
|
|
|
// Write the header.
|
|
fout << "# Install script for directory: "
|
|
<< this->StateSnapshot.GetDirectory().GetCurrentSource() << std::endl
|
|
<< std::endl;
|
|
fout << "# Set the install prefix" << std::endl
|
|
<< "if(NOT DEFINED CMAKE_INSTALL_PREFIX)" << std::endl
|
|
<< " set(CMAKE_INSTALL_PREFIX \"" << prefix << "\")" << std::endl
|
|
<< "endif()" << std::endl
|
|
<< "string(REGEX REPLACE \"/$\" \"\" CMAKE_INSTALL_PREFIX "
|
|
<< "\"${CMAKE_INSTALL_PREFIX}\")" << std::endl
|
|
<< std::endl;
|
|
|
|
// Write support code for generating per-configuration install rules.
|
|
/* clang-format off */
|
|
fout <<
|
|
"# Set the install configuration name.\n"
|
|
"if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)\n"
|
|
" if(BUILD_TYPE)\n"
|
|
" string(REGEX REPLACE \"^[^A-Za-z0-9_]+\" \"\"\n"
|
|
" CMAKE_INSTALL_CONFIG_NAME \"${BUILD_TYPE}\")\n"
|
|
" else()\n"
|
|
" set(CMAKE_INSTALL_CONFIG_NAME \"" << default_config << "\")\n"
|
|
" endif()\n"
|
|
" message(STATUS \"Install configuration: "
|
|
"\\\"${CMAKE_INSTALL_CONFIG_NAME}\\\"\")\n"
|
|
"endif()\n"
|
|
"\n";
|
|
/* clang-format on */
|
|
|
|
// Write support code for dealing with component-specific installs.
|
|
/* clang-format off */
|
|
fout <<
|
|
"# Set the component getting installed.\n"
|
|
"if(NOT CMAKE_INSTALL_COMPONENT)\n"
|
|
" if(COMPONENT)\n"
|
|
" message(STATUS \"Install component: \\\"${COMPONENT}\\\"\")\n"
|
|
" set(CMAKE_INSTALL_COMPONENT \"${COMPONENT}\")\n"
|
|
" else()\n"
|
|
" set(CMAKE_INSTALL_COMPONENT)\n"
|
|
" endif()\n"
|
|
"endif()\n"
|
|
"\n";
|
|
/* clang-format on */
|
|
|
|
// Copy user-specified install options to the install code.
|
|
if (const char* so_no_exe =
|
|
this->Makefile->GetDefinition("CMAKE_INSTALL_SO_NO_EXE")) {
|
|
/* clang-format off */
|
|
fout <<
|
|
"# Install shared libraries without execute permission?\n"
|
|
"if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)\n"
|
|
" set(CMAKE_INSTALL_SO_NO_EXE \"" << so_no_exe << "\")\n"
|
|
"endif()\n"
|
|
"\n";
|
|
/* clang-format on */
|
|
}
|
|
|
|
// Copy cmake cross compile state to install code.
|
|
if (const char* crosscompiling =
|
|
this->Makefile->GetDefinition("CMAKE_CROSSCOMPILING")) {
|
|
/* clang-format off */
|
|
fout <<
|
|
"# Is this installation the result of a crosscompile?\n"
|
|
"if(NOT DEFINED CMAKE_CROSSCOMPILING)\n"
|
|
" set(CMAKE_CROSSCOMPILING \"" << crosscompiling << "\")\n"
|
|
"endif()\n"
|
|
"\n";
|
|
/* clang-format on */
|
|
}
|
|
|
|
// Write default directory permissions.
|
|
if (const char* defaultDirPermissions = this->Makefile->GetDefinition(
|
|
"CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS")) {
|
|
/* clang-format off */
|
|
fout <<
|
|
"# Set default install directory permissions.\n"
|
|
"if(NOT DEFINED CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS)\n"
|
|
" set(CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS \""
|
|
<< defaultDirPermissions << "\")\n"
|
|
"endif()\n"
|
|
"\n";
|
|
/* clang-format on */
|
|
}
|
|
|
|
// Ask each install generator to write its code.
|
|
std::vector<cmInstallGenerator*> const& installers =
|
|
this->Makefile->GetInstallGenerators();
|
|
for (cmInstallGenerator* installer : installers) {
|
|
installer->Generate(fout, config, configurationTypes);
|
|
}
|
|
|
|
// Write rules from old-style specification stored in targets.
|
|
this->GenerateTargetInstallRules(fout, config, configurationTypes);
|
|
|
|
// Include install scripts from subdirectories.
|
|
std::vector<cmStateSnapshot> children =
|
|
this->Makefile->GetStateSnapshot().GetChildren();
|
|
if (!children.empty()) {
|
|
fout << "if(NOT CMAKE_INSTALL_LOCAL_ONLY)\n";
|
|
fout << " # Include the install script for each subdirectory.\n";
|
|
for (cmStateSnapshot const& c : children) {
|
|
if (!c.GetDirectory().GetPropertyAsBool("EXCLUDE_FROM_ALL")) {
|
|
std::string odir = c.GetDirectory().GetCurrentBinary();
|
|
cmSystemTools::ConvertToUnixSlashes(odir);
|
|
fout << " include(\"" << odir << "/cmake_install.cmake\")"
|
|
<< std::endl;
|
|
}
|
|
}
|
|
fout << "\n";
|
|
fout << "endif()\n\n";
|
|
}
|
|
|
|
// Record the install manifest.
|
|
if (toplevel_install) {
|
|
/* clang-format off */
|
|
fout <<
|
|
"if(CMAKE_INSTALL_COMPONENT)\n"
|
|
" set(CMAKE_INSTALL_MANIFEST \"install_manifest_"
|
|
"${CMAKE_INSTALL_COMPONENT}.txt\")\n"
|
|
"else()\n"
|
|
" set(CMAKE_INSTALL_MANIFEST \"install_manifest.txt\")\n"
|
|
"endif()\n"
|
|
"\n"
|
|
"string(REPLACE \";\" \"\\n\" CMAKE_INSTALL_MANIFEST_CONTENT\n"
|
|
" \"${CMAKE_INSTALL_MANIFEST_FILES}\")\n"
|
|
"file(WRITE \"" << homedir << "/${CMAKE_INSTALL_MANIFEST}\"\n"
|
|
" \"${CMAKE_INSTALL_MANIFEST_CONTENT}\")\n";
|
|
/* clang-format on */
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::AddGeneratorTarget(cmGeneratorTarget* gt)
|
|
{
|
|
this->GeneratorTargets.push_back(gt);
|
|
this->GeneratorTargetSearchIndex.emplace(gt->GetName(), gt);
|
|
this->GlobalGenerator->IndexGeneratorTarget(gt);
|
|
}
|
|
|
|
void cmLocalGenerator::AddImportedGeneratorTarget(cmGeneratorTarget* gt)
|
|
{
|
|
this->ImportedGeneratorTargets.emplace(gt->GetName(), gt);
|
|
this->GlobalGenerator->IndexGeneratorTarget(gt);
|
|
}
|
|
|
|
void cmLocalGenerator::AddOwnedImportedGeneratorTarget(cmGeneratorTarget* gt)
|
|
{
|
|
this->OwnedImportedGeneratorTargets.push_back(gt);
|
|
}
|
|
|
|
cmGeneratorTarget* cmLocalGenerator::FindLocalNonAliasGeneratorTarget(
|
|
const std::string& name) const
|
|
{
|
|
GeneratorTargetMap::const_iterator ti =
|
|
this->GeneratorTargetSearchIndex.find(name);
|
|
if (ti != this->GeneratorTargetSearchIndex.end()) {
|
|
return ti->second;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void cmLocalGenerator::ComputeTargetManifest()
|
|
{
|
|
// Collect the set of configuration types.
|
|
std::vector<std::string> configNames;
|
|
this->Makefile->GetConfigurations(configNames);
|
|
if (configNames.empty()) {
|
|
configNames.emplace_back();
|
|
}
|
|
|
|
// Add our targets to the manifest for each configuration.
|
|
const std::vector<cmGeneratorTarget*>& targets = this->GetGeneratorTargets();
|
|
for (cmGeneratorTarget* target : targets) {
|
|
if (target->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
|
|
continue;
|
|
}
|
|
for (std::string const& c : configNames) {
|
|
target->ComputeTargetManifest(c);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool cmLocalGenerator::ComputeTargetCompileFeatures()
|
|
{
|
|
// Collect the set of configuration types.
|
|
std::vector<std::string> configNames;
|
|
this->Makefile->GetConfigurations(configNames);
|
|
if (configNames.empty()) {
|
|
configNames.emplace_back();
|
|
}
|
|
|
|
// Process compile features of all targets.
|
|
const std::vector<cmGeneratorTarget*>& targets = this->GetGeneratorTargets();
|
|
for (cmGeneratorTarget* target : targets) {
|
|
for (std::string const& c : configNames) {
|
|
if (!target->ComputeCompileFeatures(c)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cmLocalGenerator::IsRootMakefile() const
|
|
{
|
|
return !this->StateSnapshot.GetBuildsystemDirectoryParent().IsValid();
|
|
}
|
|
|
|
cmState* cmLocalGenerator::GetState() const
|
|
{
|
|
return this->GlobalGenerator->GetCMakeInstance()->GetState();
|
|
}
|
|
|
|
cmStateSnapshot cmLocalGenerator::GetStateSnapshot() const
|
|
{
|
|
return this->Makefile->GetStateSnapshot();
|
|
}
|
|
|
|
const char* cmLocalGenerator::GetRuleLauncher(cmGeneratorTarget* target,
|
|
const std::string& prop)
|
|
{
|
|
if (target) {
|
|
return target->GetProperty(prop);
|
|
}
|
|
return this->Makefile->GetProperty(prop);
|
|
}
|
|
|
|
std::string cmLocalGenerator::ConvertToIncludeReference(
|
|
std::string const& path, OutputFormat format, bool forceFullPaths)
|
|
{
|
|
static_cast<void>(forceFullPaths);
|
|
return this->ConvertToOutputForExisting(path, format);
|
|
}
|
|
|
|
std::string cmLocalGenerator::GetIncludeFlags(
|
|
const std::vector<std::string>& includeDirs, cmGeneratorTarget* target,
|
|
const std::string& lang, bool forceFullPaths, bool forResponseFile,
|
|
const std::string& config)
|
|
{
|
|
if (lang.empty()) {
|
|
return "";
|
|
}
|
|
|
|
std::vector<std::string> includes = includeDirs;
|
|
this->MoveSystemIncludesToEnd(includes, config, lang, target);
|
|
|
|
OutputFormat shellFormat = forResponseFile ? RESPONSE : SHELL;
|
|
std::ostringstream includeFlags;
|
|
|
|
std::string flagVar = "CMAKE_INCLUDE_FLAG_";
|
|
flagVar += lang;
|
|
std::string const& includeFlag = this->Makefile->GetSafeDefinition(flagVar);
|
|
flagVar = "CMAKE_INCLUDE_FLAG_SEP_";
|
|
flagVar += lang;
|
|
const char* sep = this->Makefile->GetDefinition(flagVar);
|
|
bool quotePaths = false;
|
|
if (this->Makefile->GetDefinition("CMAKE_QUOTE_INCLUDE_PATHS")) {
|
|
quotePaths = true;
|
|
}
|
|
bool repeatFlag = true;
|
|
// should the include flag be repeated like ie. -IA -IB
|
|
if (!sep) {
|
|
sep = " ";
|
|
} else {
|
|
// if there is a separator then the flag is not repeated but is only
|
|
// given once i.e. -classpath a:b:c
|
|
repeatFlag = false;
|
|
}
|
|
|
|
// Support special system include flag if it is available and the
|
|
// normal flag is repeated for each directory.
|
|
std::string sysFlagVar = "CMAKE_INCLUDE_SYSTEM_FLAG_";
|
|
sysFlagVar += lang;
|
|
const char* sysIncludeFlag = nullptr;
|
|
if (repeatFlag) {
|
|
sysIncludeFlag = this->Makefile->GetDefinition(sysFlagVar);
|
|
}
|
|
|
|
std::string fwSearchFlagVar = "CMAKE_";
|
|
fwSearchFlagVar += lang;
|
|
fwSearchFlagVar += "_FRAMEWORK_SEARCH_FLAG";
|
|
const char* fwSearchFlag = this->Makefile->GetDefinition(fwSearchFlagVar);
|
|
|
|
std::string sysFwSearchFlagVar = "CMAKE_";
|
|
sysFwSearchFlagVar += lang;
|
|
sysFwSearchFlagVar += "_SYSTEM_FRAMEWORK_SEARCH_FLAG";
|
|
const char* sysFwSearchFlag =
|
|
this->Makefile->GetDefinition(sysFwSearchFlagVar);
|
|
|
|
bool flagUsed = false;
|
|
std::set<std::string> emitted;
|
|
#ifdef __APPLE__
|
|
emitted.insert("/System/Library/Frameworks");
|
|
#endif
|
|
for (std::string const& i : includes) {
|
|
if (fwSearchFlag && *fwSearchFlag && this->Makefile->IsOn("APPLE") &&
|
|
cmSystemTools::IsPathToFramework(i.c_str())) {
|
|
std::string frameworkDir = i;
|
|
frameworkDir += "/../";
|
|
frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir);
|
|
if (emitted.insert(frameworkDir).second) {
|
|
if (sysFwSearchFlag && target &&
|
|
target->IsSystemIncludeDirectory(i, config, lang)) {
|
|
includeFlags << sysFwSearchFlag;
|
|
} else {
|
|
includeFlags << fwSearchFlag;
|
|
}
|
|
includeFlags << this->ConvertToOutputFormat(frameworkDir, shellFormat)
|
|
<< " ";
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (!flagUsed || repeatFlag) {
|
|
if (sysIncludeFlag && target &&
|
|
target->IsSystemIncludeDirectory(i, config, lang)) {
|
|
includeFlags << sysIncludeFlag;
|
|
} else {
|
|
includeFlags << includeFlag;
|
|
}
|
|
flagUsed = true;
|
|
}
|
|
std::string includePath =
|
|
this->ConvertToIncludeReference(i, shellFormat, forceFullPaths);
|
|
if (quotePaths && !includePath.empty() && includePath[0] != '\"') {
|
|
includeFlags << "\"";
|
|
}
|
|
includeFlags << includePath;
|
|
if (quotePaths && !includePath.empty() && includePath[0] != '\"') {
|
|
includeFlags << "\"";
|
|
}
|
|
includeFlags << sep;
|
|
}
|
|
std::string flags = includeFlags.str();
|
|
// remove trailing separators
|
|
if ((sep[0] != ' ') && !flags.empty() && flags[flags.size() - 1] == sep[0]) {
|
|
flags[flags.size() - 1] = ' ';
|
|
}
|
|
return flags;
|
|
}
|
|
|
|
void cmLocalGenerator::AddCompileDefinitions(std::set<std::string>& defines,
|
|
cmGeneratorTarget const* target,
|
|
const std::string& config,
|
|
const std::string& lang) const
|
|
{
|
|
std::vector<std::string> targetDefines;
|
|
target->GetCompileDefinitions(targetDefines, config, lang);
|
|
this->AppendDefines(defines, targetDefines);
|
|
}
|
|
|
|
void cmLocalGenerator::AddCompileOptions(std::string& flags,
|
|
cmGeneratorTarget* target,
|
|
const std::string& lang,
|
|
const std::string& config)
|
|
{
|
|
std::string langFlagRegexVar = std::string("CMAKE_") + lang + "_FLAG_REGEX";
|
|
|
|
if (const char* langFlagRegexStr =
|
|
this->Makefile->GetDefinition(langFlagRegexVar)) {
|
|
// Filter flags acceptable to this language.
|
|
std::vector<std::string> opts;
|
|
if (const char* targetFlags = target->GetProperty("COMPILE_FLAGS")) {
|
|
cmSystemTools::ParseWindowsCommandLine(targetFlags, opts);
|
|
}
|
|
target->GetCompileOptions(opts, config, lang);
|
|
// (Re-)Escape these flags. COMPILE_FLAGS were already parsed
|
|
// as a command line above, and COMPILE_OPTIONS are escaped.
|
|
this->AppendCompileOptions(flags, opts, langFlagRegexStr);
|
|
} else {
|
|
// Use all flags.
|
|
if (const char* targetFlags = target->GetProperty("COMPILE_FLAGS")) {
|
|
// COMPILE_FLAGS are not escaped for historical reasons.
|
|
this->AppendFlags(flags, targetFlags);
|
|
}
|
|
std::vector<std::string> opts;
|
|
target->GetCompileOptions(opts, config, lang);
|
|
// COMPILE_OPTIONS are escaped.
|
|
this->AppendCompileOptions(flags, opts);
|
|
}
|
|
|
|
for (auto const& it : target->GetMaxLanguageStandards()) {
|
|
const char* standard = target->GetProperty(it.first + "_STANDARD");
|
|
if (!standard) {
|
|
continue;
|
|
}
|
|
if (this->Makefile->IsLaterStandard(it.first, standard, it.second)) {
|
|
std::ostringstream e;
|
|
e << "The COMPILE_FEATURES property of target \"" << target->GetName()
|
|
<< "\" was evaluated when computing the link "
|
|
"implementation, and the \""
|
|
<< it.first << "_STANDARD\" was \"" << it.second
|
|
<< "\" for that computation. Computing the "
|
|
"COMPILE_FEATURES based on the link implementation resulted in a "
|
|
"higher \""
|
|
<< it.first << "_STANDARD\" \"" << standard
|
|
<< "\". "
|
|
"This is not permitted. The COMPILE_FEATURES may not both depend "
|
|
"on "
|
|
"and be depended on by the link implementation."
|
|
<< std::endl;
|
|
this->IssueMessage(cmake::FATAL_ERROR, e.str());
|
|
return;
|
|
}
|
|
}
|
|
this->AddCompilerRequirementFlag(flags, target, lang);
|
|
}
|
|
|
|
void cmLocalGenerator::GetIncludeDirectories(std::vector<std::string>& dirs,
|
|
cmGeneratorTarget const* target,
|
|
const std::string& lang,
|
|
const std::string& config,
|
|
bool stripImplicitDirs,
|
|
bool appendAllImplicitDirs) const
|
|
{
|
|
// Do not repeat an include path.
|
|
std::set<std::string> emitted;
|
|
|
|
// When automatic include directories are requested for a build then
|
|
// include the source and binary directories at the beginning of the
|
|
// include path to approximate include file behavior for an
|
|
// in-source build. This does not account for the case of a source
|
|
// file in a subdirectory of the current source directory but we
|
|
// cannot fix this because not all native build tools support
|
|
// per-source-file include paths.
|
|
if (this->Makefile->IsOn("CMAKE_INCLUDE_CURRENT_DIR")) {
|
|
// Current binary directory
|
|
{
|
|
std::string binDir =
|
|
this->StateSnapshot.GetDirectory().GetCurrentBinary();
|
|
if (emitted.insert(binDir).second) {
|
|
dirs.push_back(std::move(binDir));
|
|
}
|
|
}
|
|
// Current source directory
|
|
{
|
|
std::string srcDir =
|
|
this->StateSnapshot.GetDirectory().GetCurrentSource();
|
|
if (emitted.insert(srcDir).second) {
|
|
dirs.push_back(std::move(srcDir));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!target) {
|
|
return;
|
|
}
|
|
|
|
// Implicit include directories
|
|
std::vector<std::string> implicitDirs;
|
|
{
|
|
std::string rootPath;
|
|
if (const char* sysrootCompile =
|
|
this->Makefile->GetDefinition("CMAKE_SYSROOT_COMPILE")) {
|
|
rootPath = sysrootCompile;
|
|
} else {
|
|
rootPath = this->Makefile->GetSafeDefinition("CMAKE_SYSROOT");
|
|
}
|
|
|
|
// Load implicit include directories for this language.
|
|
std::string key = "CMAKE_";
|
|
key += lang;
|
|
key += "_IMPLICIT_INCLUDE_DIRECTORIES";
|
|
if (const char* value = this->Makefile->GetDefinition(key)) {
|
|
std::vector<std::string> impDirVec;
|
|
cmSystemTools::ExpandListArgument(value, impDirVec);
|
|
for (std::string const& i : impDirVec) {
|
|
{
|
|
std::string d = rootPath + i;
|
|
cmSystemTools::ConvertToUnixSlashes(d);
|
|
emitted.insert(std::move(d));
|
|
}
|
|
implicitDirs.push_back(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get the target-specific include directories.
|
|
std::vector<std::string> userDirs =
|
|
target->GetIncludeDirectories(config, lang);
|
|
|
|
// Support putting all the in-project include directories first if
|
|
// it is requested by the project.
|
|
if (this->Makefile->IsOn("CMAKE_INCLUDE_DIRECTORIES_PROJECT_BEFORE")) {
|
|
std::string const &topSourceDir = this->GetState()->GetSourceDirectory(),
|
|
&topBinaryDir = this->GetState()->GetBinaryDirectory();
|
|
for (std::string const& i : userDirs) {
|
|
// Emit this directory only if it is a subdirectory of the
|
|
// top-level source or binary tree.
|
|
if (cmSystemTools::ComparePath(i, topSourceDir) ||
|
|
cmSystemTools::ComparePath(i, topBinaryDir) ||
|
|
cmSystemTools::IsSubDirectory(i, topSourceDir) ||
|
|
cmSystemTools::IsSubDirectory(i, topBinaryDir)) {
|
|
if (emitted.insert(i).second) {
|
|
dirs.push_back(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Construct the final ordered include directory list.
|
|
for (std::string const& i : userDirs) {
|
|
if (emitted.insert(i).second) {
|
|
dirs.push_back(i);
|
|
}
|
|
}
|
|
|
|
this->MoveSystemIncludesToEnd(dirs, config, lang, target);
|
|
|
|
// Add standard include directories for this language.
|
|
{
|
|
std::vector<std::string>::size_type const before = userDirs.size();
|
|
{
|
|
std::string key = "CMAKE_";
|
|
key += lang;
|
|
key += "_STANDARD_INCLUDE_DIRECTORIES";
|
|
std::string const value = this->Makefile->GetSafeDefinition(key);
|
|
cmSystemTools::ExpandListArgument(value, userDirs);
|
|
}
|
|
for (std::vector<std::string>::iterator i = userDirs.begin() + before,
|
|
ie = userDirs.end();
|
|
i != ie; ++i) {
|
|
cmSystemTools::ConvertToUnixSlashes(*i);
|
|
dirs.push_back(*i);
|
|
}
|
|
}
|
|
|
|
if (!stripImplicitDirs) {
|
|
// Append only implicit directories that were requested by the user
|
|
for (std::string const& i : implicitDirs) {
|
|
if (std::find(userDirs.begin(), userDirs.end(), i) != userDirs.end()) {
|
|
dirs.push_back(i);
|
|
}
|
|
}
|
|
// Append remaining implicit directories on demand
|
|
if (appendAllImplicitDirs) {
|
|
for (std::string const& i : implicitDirs) {
|
|
if (std::find(dirs.begin(), dirs.end(), i) == dirs.end()) {
|
|
dirs.push_back(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::GetStaticLibraryFlags(std::string& flags,
|
|
std::string const& config,
|
|
std::string const& linkLanguage,
|
|
cmGeneratorTarget* target)
|
|
{
|
|
this->AppendFlags(
|
|
flags, this->Makefile->GetSafeDefinition("CMAKE_STATIC_LINKER_FLAGS"));
|
|
if (!config.empty()) {
|
|
std::string name = "CMAKE_STATIC_LINKER_FLAGS_" + config;
|
|
this->AppendFlags(flags, this->Makefile->GetSafeDefinition(name));
|
|
}
|
|
this->AppendFlags(flags, target->GetProperty("STATIC_LIBRARY_FLAGS"));
|
|
if (!config.empty()) {
|
|
std::string name = "STATIC_LIBRARY_FLAGS_" + config;
|
|
this->AppendFlags(flags, target->GetProperty(name));
|
|
}
|
|
|
|
std::vector<std::string> options;
|
|
target->GetStaticLibraryLinkOptions(options, config, linkLanguage);
|
|
// STATIC_LIBRARY_OPTIONS are escaped.
|
|
this->AppendCompileOptions(flags, options);
|
|
}
|
|
|
|
void cmLocalGenerator::GetTargetFlags(
|
|
cmLinkLineComputer* linkLineComputer, const std::string& config,
|
|
std::string& linkLibs, std::string& flags, std::string& linkFlags,
|
|
std::string& frameworkPath, std::string& linkPath, cmGeneratorTarget* target)
|
|
{
|
|
const std::string buildType = cmSystemTools::UpperCase(config);
|
|
cmComputeLinkInformation* pcli = target->GetLinkInformation(config);
|
|
const char* libraryLinkVariable =
|
|
"CMAKE_SHARED_LINKER_FLAGS"; // default to shared library
|
|
|
|
const std::string linkLanguage =
|
|
linkLineComputer->GetLinkerLanguage(target, buildType);
|
|
|
|
switch (target->GetType()) {
|
|
case cmStateEnums::STATIC_LIBRARY:
|
|
this->GetStaticLibraryFlags(linkFlags, buildType, linkLanguage, target);
|
|
break;
|
|
case cmStateEnums::MODULE_LIBRARY:
|
|
libraryLinkVariable = "CMAKE_MODULE_LINKER_FLAGS";
|
|
CM_FALLTHROUGH;
|
|
case cmStateEnums::SHARED_LIBRARY: {
|
|
linkFlags = this->Makefile->GetSafeDefinition(libraryLinkVariable);
|
|
linkFlags += " ";
|
|
if (!buildType.empty()) {
|
|
std::string build = libraryLinkVariable;
|
|
build += "_";
|
|
build += buildType;
|
|
linkFlags += this->Makefile->GetSafeDefinition(build);
|
|
linkFlags += " ";
|
|
}
|
|
if (this->Makefile->IsOn("WIN32") &&
|
|
!(this->Makefile->IsOn("CYGWIN") || this->Makefile->IsOn("MINGW"))) {
|
|
std::vector<cmSourceFile*> sources;
|
|
target->GetSourceFiles(sources, buildType);
|
|
std::string defFlag =
|
|
this->Makefile->GetSafeDefinition("CMAKE_LINK_DEF_FILE_FLAG");
|
|
for (cmSourceFile* sf : sources) {
|
|
if (sf->GetExtension() == "def") {
|
|
linkFlags += defFlag;
|
|
linkFlags += this->ConvertToOutputFormat(
|
|
cmSystemTools::CollapseFullPath(sf->GetFullPath()), SHELL);
|
|
linkFlags += " ";
|
|
}
|
|
}
|
|
}
|
|
const char* targetLinkFlags = target->GetProperty("LINK_FLAGS");
|
|
if (targetLinkFlags) {
|
|
linkFlags += targetLinkFlags;
|
|
linkFlags += " ";
|
|
}
|
|
if (!buildType.empty()) {
|
|
std::string configLinkFlags = "LINK_FLAGS_";
|
|
configLinkFlags += buildType;
|
|
targetLinkFlags = target->GetProperty(configLinkFlags);
|
|
if (targetLinkFlags) {
|
|
linkFlags += targetLinkFlags;
|
|
linkFlags += " ";
|
|
}
|
|
}
|
|
std::vector<std::string> opts;
|
|
target->GetLinkOptions(opts, config, linkLanguage);
|
|
// LINK_OPTIONS are escaped.
|
|
this->AppendCompileOptions(linkFlags, opts);
|
|
if (pcli) {
|
|
this->OutputLinkLibraries(pcli, linkLineComputer, linkLibs,
|
|
frameworkPath, linkPath);
|
|
}
|
|
} break;
|
|
case cmStateEnums::EXECUTABLE: {
|
|
linkFlags += this->Makefile->GetSafeDefinition("CMAKE_EXE_LINKER_FLAGS");
|
|
linkFlags += " ";
|
|
if (!buildType.empty()) {
|
|
std::string build = "CMAKE_EXE_LINKER_FLAGS_";
|
|
build += buildType;
|
|
linkFlags += this->Makefile->GetSafeDefinition(build);
|
|
linkFlags += " ";
|
|
}
|
|
if (linkLanguage.empty()) {
|
|
cmSystemTools::Error(
|
|
"CMake can not determine linker language for target: ",
|
|
target->GetName().c_str());
|
|
return;
|
|
}
|
|
this->AddLanguageFlagsForLinking(flags, target, linkLanguage, buildType);
|
|
if (pcli) {
|
|
this->OutputLinkLibraries(pcli, linkLineComputer, linkLibs,
|
|
frameworkPath, linkPath);
|
|
}
|
|
if (cmSystemTools::IsOn(
|
|
this->Makefile->GetDefinition("BUILD_SHARED_LIBS"))) {
|
|
std::string sFlagVar = std::string("CMAKE_SHARED_BUILD_") +
|
|
linkLanguage + std::string("_FLAGS");
|
|
linkFlags += this->Makefile->GetSafeDefinition(sFlagVar);
|
|
linkFlags += " ";
|
|
}
|
|
if (target->GetPropertyAsBool("WIN32_EXECUTABLE")) {
|
|
linkFlags +=
|
|
this->Makefile->GetSafeDefinition("CMAKE_CREATE_WIN32_EXE");
|
|
linkFlags += " ";
|
|
} else {
|
|
linkFlags +=
|
|
this->Makefile->GetSafeDefinition("CMAKE_CREATE_CONSOLE_EXE");
|
|
linkFlags += " ";
|
|
}
|
|
if (target->IsExecutableWithExports()) {
|
|
std::string exportFlagVar = "CMAKE_EXE_EXPORTS_";
|
|
exportFlagVar += linkLanguage;
|
|
exportFlagVar += "_FLAG";
|
|
|
|
linkFlags += this->Makefile->GetSafeDefinition(exportFlagVar);
|
|
linkFlags += " ";
|
|
}
|
|
|
|
std::string cmp0065Flags =
|
|
this->GetLinkLibsCMP0065(linkLanguage, *target);
|
|
if (!cmp0065Flags.empty()) {
|
|
linkFlags += cmp0065Flags;
|
|
linkFlags += " ";
|
|
}
|
|
|
|
const char* targetLinkFlags = target->GetProperty("LINK_FLAGS");
|
|
if (targetLinkFlags) {
|
|
linkFlags += targetLinkFlags;
|
|
linkFlags += " ";
|
|
}
|
|
if (!buildType.empty()) {
|
|
std::string configLinkFlags = "LINK_FLAGS_";
|
|
configLinkFlags += buildType;
|
|
targetLinkFlags = target->GetProperty(configLinkFlags);
|
|
if (targetLinkFlags) {
|
|
linkFlags += targetLinkFlags;
|
|
linkFlags += " ";
|
|
}
|
|
}
|
|
std::vector<std::string> opts;
|
|
target->GetLinkOptions(opts, config, linkLanguage);
|
|
// LINK_OPTIONS are escaped.
|
|
this->AppendCompileOptions(linkFlags, opts);
|
|
} break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
this->AppendIPOLinkerFlags(linkFlags, target, config, linkLanguage);
|
|
}
|
|
|
|
void cmLocalGenerator::GetTargetCompileFlags(cmGeneratorTarget* target,
|
|
std::string const& config,
|
|
std::string const& lang,
|
|
std::string& flags)
|
|
{
|
|
cmMakefile* mf = this->GetMakefile();
|
|
|
|
// Add language-specific flags.
|
|
this->AddLanguageFlags(flags, target, lang, config);
|
|
|
|
this->AddArchitectureFlags(flags, target, lang, config);
|
|
|
|
if (lang == "Fortran") {
|
|
this->AppendFlags(flags, this->GetTargetFortranFlags(target, config));
|
|
}
|
|
|
|
this->AddCMP0018Flags(flags, target, lang, config);
|
|
this->AddVisibilityPresetFlags(flags, target, lang);
|
|
this->AppendFlags(flags, mf->GetDefineFlags());
|
|
this->AppendFlags(flags, this->GetFrameworkFlags(lang, config, target));
|
|
this->AddCompileOptions(flags, target, lang, config);
|
|
}
|
|
|
|
static std::string GetFrameworkFlags(const std::string& lang,
|
|
const std::string& config,
|
|
cmGeneratorTarget* target)
|
|
{
|
|
cmLocalGenerator* lg = target->GetLocalGenerator();
|
|
cmMakefile* mf = lg->GetMakefile();
|
|
|
|
if (!mf->IsOn("APPLE")) {
|
|
return std::string();
|
|
}
|
|
|
|
std::string fwSearchFlagVar = "CMAKE_" + lang + "_FRAMEWORK_SEARCH_FLAG";
|
|
const char* fwSearchFlag = mf->GetDefinition(fwSearchFlagVar);
|
|
if (!(fwSearchFlag && *fwSearchFlag)) {
|
|
return std::string();
|
|
}
|
|
|
|
std::set<std::string> emitted;
|
|
#ifdef __APPLE__ /* don't insert this when crosscompiling e.g. to iphone */
|
|
emitted.insert("/System/Library/Frameworks");
|
|
#endif
|
|
std::vector<std::string> includes;
|
|
|
|
lg->GetIncludeDirectories(includes, target, "C", config);
|
|
// check all include directories for frameworks as this
|
|
// will already have added a -F for the framework
|
|
for (std::string const& include : includes) {
|
|
if (lg->GetGlobalGenerator()->NameResolvesToFramework(include)) {
|
|
std::string frameworkDir = include;
|
|
frameworkDir += "/../";
|
|
frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir);
|
|
emitted.insert(frameworkDir);
|
|
}
|
|
}
|
|
|
|
std::string flags;
|
|
if (cmComputeLinkInformation* cli = target->GetLinkInformation(config)) {
|
|
std::vector<std::string> const& frameworks = cli->GetFrameworkPaths();
|
|
for (std::string const& framework : frameworks) {
|
|
if (emitted.insert(framework).second) {
|
|
flags += fwSearchFlag;
|
|
flags +=
|
|
lg->ConvertToOutputFormat(framework, cmOutputConverter::SHELL);
|
|
flags += " ";
|
|
}
|
|
}
|
|
}
|
|
return flags;
|
|
}
|
|
|
|
std::string cmLocalGenerator::GetFrameworkFlags(std::string const& l,
|
|
std::string const& config,
|
|
cmGeneratorTarget* target)
|
|
{
|
|
return ::GetFrameworkFlags(l, config, target);
|
|
}
|
|
|
|
void cmLocalGenerator::GetTargetDefines(cmGeneratorTarget const* target,
|
|
std::string const& config,
|
|
std::string const& lang,
|
|
std::set<std::string>& defines) const
|
|
{
|
|
// Add the export symbol definition for shared library objects.
|
|
if (const char* exportMacro = target->GetExportMacro()) {
|
|
this->AppendDefines(defines, exportMacro);
|
|
}
|
|
|
|
// Add preprocessor definitions for this target and configuration.
|
|
this->AddCompileDefinitions(defines, target, config, lang);
|
|
}
|
|
|
|
std::string cmLocalGenerator::GetTargetFortranFlags(
|
|
cmGeneratorTarget const* /*unused*/, std::string const& /*unused*/)
|
|
{
|
|
// Implemented by specific generators that override this.
|
|
return std::string();
|
|
}
|
|
|
|
/**
|
|
* Output the linking rules on a command line. For executables,
|
|
* targetLibrary should be a NULL pointer. For libraries, it should point
|
|
* to the name of the library. This will not link a library against itself.
|
|
*/
|
|
void cmLocalGenerator::OutputLinkLibraries(
|
|
cmComputeLinkInformation* pcli, cmLinkLineComputer* linkLineComputer,
|
|
std::string& linkLibraries, std::string& frameworkPath,
|
|
std::string& linkPath)
|
|
{
|
|
cmComputeLinkInformation& cli = *pcli;
|
|
|
|
std::string linkLanguage = cli.GetLinkLanguage();
|
|
|
|
std::string libPathFlag =
|
|
this->Makefile->GetRequiredDefinition("CMAKE_LIBRARY_PATH_FLAG");
|
|
std::string libPathTerminator =
|
|
this->Makefile->GetSafeDefinition("CMAKE_LIBRARY_PATH_TERMINATOR");
|
|
|
|
// Add standard libraries for this language.
|
|
std::string standardLibsVar = "CMAKE_";
|
|
standardLibsVar += cli.GetLinkLanguage();
|
|
standardLibsVar += "_STANDARD_LIBRARIES";
|
|
std::string stdLibString;
|
|
if (const char* stdLibs = this->Makefile->GetDefinition(standardLibsVar)) {
|
|
stdLibString = stdLibs;
|
|
}
|
|
|
|
// Append the framework search path flags.
|
|
std::string fwSearchFlagVar = "CMAKE_";
|
|
fwSearchFlagVar += linkLanguage;
|
|
fwSearchFlagVar += "_FRAMEWORK_SEARCH_FLAG";
|
|
std::string fwSearchFlag =
|
|
this->Makefile->GetSafeDefinition(fwSearchFlagVar);
|
|
|
|
frameworkPath = linkLineComputer->ComputeFrameworkPath(cli, fwSearchFlag);
|
|
linkPath =
|
|
linkLineComputer->ComputeLinkPath(cli, libPathFlag, libPathTerminator);
|
|
|
|
linkLibraries = linkLineComputer->ComputeLinkLibraries(cli, stdLibString);
|
|
}
|
|
|
|
std::string cmLocalGenerator::GetLinkLibsCMP0065(
|
|
std::string const& linkLanguage, cmGeneratorTarget& tgt) const
|
|
{
|
|
std::string linkFlags;
|
|
|
|
// Flags to link an executable to shared libraries.
|
|
if (tgt.GetType() == cmStateEnums::EXECUTABLE &&
|
|
this->StateSnapshot.GetState()->GetGlobalPropertyAsBool(
|
|
"TARGET_SUPPORTS_SHARED_LIBS")) {
|
|
bool add_shlib_flags = false;
|
|
switch (tgt.GetPolicyStatusCMP0065()) {
|
|
case cmPolicies::WARN:
|
|
if (!tgt.GetPropertyAsBool("ENABLE_EXPORTS") &&
|
|
this->Makefile->PolicyOptionalWarningEnabled(
|
|
"CMAKE_POLICY_WARNING_CMP0065")) {
|
|
std::ostringstream w;
|
|
/* clang-format off */
|
|
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0065) << "\n"
|
|
"For compatibility with older versions of CMake, "
|
|
"additional flags may be added to export symbols on all "
|
|
"executables regardless of their ENABLE_EXPORTS property.";
|
|
/* clang-format on */
|
|
this->IssueMessage(cmake::AUTHOR_WARNING, w.str());
|
|
}
|
|
CM_FALLTHROUGH;
|
|
case cmPolicies::OLD:
|
|
// OLD behavior is to always add the flags
|
|
add_shlib_flags = true;
|
|
break;
|
|
case cmPolicies::REQUIRED_IF_USED:
|
|
case cmPolicies::REQUIRED_ALWAYS:
|
|
this->IssueMessage(
|
|
cmake::FATAL_ERROR,
|
|
cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0065));
|
|
CM_FALLTHROUGH;
|
|
case cmPolicies::NEW:
|
|
// NEW behavior is to only add the flags if ENABLE_EXPORTS is on
|
|
add_shlib_flags = tgt.GetPropertyAsBool("ENABLE_EXPORTS");
|
|
break;
|
|
}
|
|
|
|
if (add_shlib_flags) {
|
|
std::string linkFlagsVar = "CMAKE_SHARED_LIBRARY_LINK_";
|
|
linkFlagsVar += linkLanguage;
|
|
linkFlagsVar += "_FLAGS";
|
|
linkFlags = this->Makefile->GetSafeDefinition(linkFlagsVar);
|
|
}
|
|
}
|
|
return linkFlags;
|
|
}
|
|
|
|
void cmLocalGenerator::AddArchitectureFlags(std::string& flags,
|
|
cmGeneratorTarget const* target,
|
|
const std::string& lang,
|
|
const std::string& config)
|
|
{
|
|
// Only add macOS specific flags on Darwin platforms (macOS and iOS):
|
|
if (this->Makefile->IsOn("APPLE") && this->EmitUniversalBinaryFlags) {
|
|
std::vector<std::string> archs;
|
|
target->GetAppleArchs(config, archs);
|
|
const char* sysroot = this->Makefile->GetDefinition("CMAKE_OSX_SYSROOT");
|
|
if (sysroot && sysroot[0] == '/' && !sysroot[1]) {
|
|
sysroot = nullptr;
|
|
}
|
|
std::string sysrootFlagVar =
|
|
std::string("CMAKE_") + lang + "_SYSROOT_FLAG";
|
|
const char* sysrootFlag = this->Makefile->GetDefinition(sysrootFlagVar);
|
|
const char* deploymentTarget =
|
|
this->Makefile->GetDefinition("CMAKE_OSX_DEPLOYMENT_TARGET");
|
|
std::string deploymentTargetFlagVar =
|
|
std::string("CMAKE_") + lang + "_OSX_DEPLOYMENT_TARGET_FLAG";
|
|
const char* deploymentTargetFlag =
|
|
this->Makefile->GetDefinition(deploymentTargetFlagVar);
|
|
if (!archs.empty() && !lang.empty() &&
|
|
(lang[0] == 'C' || lang[0] == 'F')) {
|
|
for (std::string const& arch : archs) {
|
|
flags += " -arch ";
|
|
flags += arch;
|
|
}
|
|
}
|
|
|
|
if (sysrootFlag && *sysrootFlag && sysroot && *sysroot) {
|
|
flags += " ";
|
|
flags += sysrootFlag;
|
|
flags += " ";
|
|
flags += this->ConvertToOutputFormat(sysroot, SHELL);
|
|
}
|
|
|
|
if (deploymentTargetFlag && *deploymentTargetFlag && deploymentTarget &&
|
|
*deploymentTarget) {
|
|
flags += " ";
|
|
flags += deploymentTargetFlag;
|
|
flags += deploymentTarget;
|
|
}
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::AddLanguageFlags(std::string& flags,
|
|
cmGeneratorTarget const* target,
|
|
const std::string& lang,
|
|
const std::string& config)
|
|
{
|
|
// Add language-specific flags.
|
|
std::string flagsVar = "CMAKE_";
|
|
flagsVar += lang;
|
|
flagsVar += "_FLAGS";
|
|
this->AddConfigVariableFlags(flags, flagsVar, config);
|
|
|
|
if (target->IsIPOEnabled(lang, config)) {
|
|
this->AppendFeatureOptions(flags, lang, "IPO");
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::AddLanguageFlagsForLinking(
|
|
std::string& flags, cmGeneratorTarget const* target, const std::string& lang,
|
|
const std::string& config)
|
|
{
|
|
if (this->Makefile->IsOn("CMAKE_" + lang +
|
|
"_LINK_WITH_STANDARD_COMPILE_OPTION")) {
|
|
// This toolchain requires use of the language standard flag
|
|
// when linking in order to use the matching standard library.
|
|
// FIXME: If CMake gains an abstraction for standard library
|
|
// selection, this will have to be reconciled with it.
|
|
this->AddCompilerRequirementFlag(flags, target, lang);
|
|
}
|
|
|
|
this->AddLanguageFlags(flags, target, lang, config);
|
|
}
|
|
|
|
cmGeneratorTarget* cmLocalGenerator::FindGeneratorTargetToUse(
|
|
const std::string& name) const
|
|
{
|
|
GeneratorTargetMap::const_iterator imported =
|
|
this->ImportedGeneratorTargets.find(name);
|
|
if (imported != this->ImportedGeneratorTargets.end()) {
|
|
return imported->second;
|
|
}
|
|
|
|
if (cmGeneratorTarget* t = this->FindLocalNonAliasGeneratorTarget(name)) {
|
|
return t;
|
|
}
|
|
|
|
return this->GetGlobalGenerator()->FindGeneratorTarget(name);
|
|
}
|
|
|
|
bool cmLocalGenerator::GetRealDependency(const std::string& inName,
|
|
const std::string& config,
|
|
std::string& dep)
|
|
{
|
|
// Older CMake code may specify the dependency using the target
|
|
// output file rather than the target name. Such code would have
|
|
// been written before there was support for target properties that
|
|
// modify the name so stripping down to just the file name should
|
|
// produce the target name in this case.
|
|
std::string name = cmSystemTools::GetFilenameName(inName);
|
|
|
|
// If the input name is the empty string, there is no real
|
|
// dependency. Short-circuit the other checks:
|
|
if (name.empty()) {
|
|
return false;
|
|
}
|
|
|
|
if (cmSystemTools::GetFilenameLastExtension(name) == ".exe") {
|
|
name = cmSystemTools::GetFilenameWithoutLastExtension(name);
|
|
}
|
|
|
|
// Look for a CMake target with the given name.
|
|
if (cmGeneratorTarget* target = this->FindGeneratorTargetToUse(name)) {
|
|
// make sure it is not just a coincidence that the target name
|
|
// found is part of the inName
|
|
if (cmSystemTools::FileIsFullPath(inName)) {
|
|
std::string tLocation;
|
|
if (target->GetType() >= cmStateEnums::EXECUTABLE &&
|
|
target->GetType() <= cmStateEnums::MODULE_LIBRARY) {
|
|
tLocation = target->GetLocation(config);
|
|
tLocation = cmSystemTools::GetFilenamePath(tLocation);
|
|
tLocation = cmSystemTools::CollapseFullPath(tLocation);
|
|
}
|
|
std::string depLocation =
|
|
cmSystemTools::GetFilenamePath(std::string(inName));
|
|
depLocation = cmSystemTools::CollapseFullPath(depLocation);
|
|
if (depLocation != tLocation) {
|
|
// it is a full path to a depend that has the same name
|
|
// as a target but is in a different location so do not use
|
|
// the target as the depend
|
|
dep = inName;
|
|
return true;
|
|
}
|
|
}
|
|
switch (target->GetType()) {
|
|
case cmStateEnums::EXECUTABLE:
|
|
case cmStateEnums::STATIC_LIBRARY:
|
|
case cmStateEnums::SHARED_LIBRARY:
|
|
case cmStateEnums::MODULE_LIBRARY:
|
|
case cmStateEnums::UNKNOWN_LIBRARY:
|
|
dep = target->GetLocation(config);
|
|
return true;
|
|
case cmStateEnums::OBJECT_LIBRARY:
|
|
// An object library has no single file on which to depend.
|
|
// This was listed to get the target-level dependency.
|
|
return false;
|
|
case cmStateEnums::INTERFACE_LIBRARY:
|
|
// An interface library has no file on which to depend.
|
|
// This was listed to get the target-level dependency.
|
|
return false;
|
|
case cmStateEnums::UTILITY:
|
|
case cmStateEnums::GLOBAL_TARGET:
|
|
// A utility target has no file on which to depend. This was listed
|
|
// only to get the target-level dependency.
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// The name was not that of a CMake target. It must name a file.
|
|
if (cmSystemTools::FileIsFullPath(inName)) {
|
|
// This is a full path. Return it as given.
|
|
dep = inName;
|
|
return true;
|
|
}
|
|
|
|
// Check for a source file in this directory that matches the
|
|
// dependency.
|
|
if (cmSourceFile* sf = this->Makefile->GetSource(inName)) {
|
|
dep = sf->GetFullPath();
|
|
return true;
|
|
}
|
|
|
|
// Treat the name as relative to the source directory in which it
|
|
// was given.
|
|
dep = this->StateSnapshot.GetDirectory().GetCurrentSource();
|
|
dep += "/";
|
|
dep += inName;
|
|
return true;
|
|
}
|
|
|
|
void cmLocalGenerator::AddSharedFlags(std::string& flags,
|
|
const std::string& lang, bool shared)
|
|
{
|
|
std::string flagsVar;
|
|
|
|
// Add flags for dealing with shared libraries for this language.
|
|
if (shared) {
|
|
flagsVar = "CMAKE_SHARED_LIBRARY_";
|
|
flagsVar += lang;
|
|
flagsVar += "_FLAGS";
|
|
this->AppendFlags(flags, this->Makefile->GetDefinition(flagsVar));
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::AddCompilerRequirementFlag(
|
|
std::string& flags, cmGeneratorTarget const* target, const std::string& lang)
|
|
{
|
|
if (lang.empty()) {
|
|
return;
|
|
}
|
|
const char* defaultStd =
|
|
this->Makefile->GetDefinition("CMAKE_" + lang + "_STANDARD_DEFAULT");
|
|
if (!defaultStd || !*defaultStd) {
|
|
// This compiler has no notion of language standard levels.
|
|
return;
|
|
}
|
|
std::string extProp = lang + "_EXTENSIONS";
|
|
bool ext = true;
|
|
if (const char* extPropValue = target->GetProperty(extProp)) {
|
|
if (cmSystemTools::IsOff(extPropValue)) {
|
|
ext = false;
|
|
}
|
|
}
|
|
std::string stdProp = lang + "_STANDARD";
|
|
const char* standardProp = target->GetProperty(stdProp);
|
|
if (!standardProp) {
|
|
if (ext) {
|
|
// No language standard is specified and extensions are not disabled.
|
|
// Check if this compiler needs a flag to enable extensions.
|
|
std::string const option_flag =
|
|
"CMAKE_" + lang + "_EXTENSION_COMPILE_OPTION";
|
|
if (const char* opt =
|
|
target->Target->GetMakefile()->GetDefinition(option_flag)) {
|
|
std::vector<std::string> optVec;
|
|
cmSystemTools::ExpandListArgument(opt, optVec);
|
|
for (std::string const& i : optVec) {
|
|
this->AppendFlagEscape(flags, i);
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
std::string const type = ext ? "EXTENSION" : "STANDARD";
|
|
|
|
if (target->GetPropertyAsBool(lang + "_STANDARD_REQUIRED")) {
|
|
std::string option_flag =
|
|
"CMAKE_" + lang + standardProp + "_" + type + "_COMPILE_OPTION";
|
|
|
|
const char* opt =
|
|
target->Target->GetMakefile()->GetDefinition(option_flag);
|
|
if (!opt) {
|
|
std::ostringstream e;
|
|
e << "Target \"" << target->GetName()
|
|
<< "\" requires the language "
|
|
"dialect \""
|
|
<< lang << standardProp << "\" "
|
|
<< (ext ? "(with compiler extensions)" : "")
|
|
<< ", but CMake "
|
|
"does not know the compile flags to use to enable it.";
|
|
this->IssueMessage(cmake::FATAL_ERROR, e.str());
|
|
} else {
|
|
std::vector<std::string> optVec;
|
|
cmSystemTools::ExpandListArgument(opt, optVec);
|
|
for (std::string const& i : optVec) {
|
|
this->AppendFlagEscape(flags, i);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
static std::map<std::string, std::vector<std::string>> langStdMap;
|
|
if (langStdMap.empty()) {
|
|
// Maintain sorted order, most recent first.
|
|
langStdMap["CXX"].push_back("20");
|
|
langStdMap["CXX"].push_back("17");
|
|
langStdMap["CXX"].push_back("14");
|
|
langStdMap["CXX"].push_back("11");
|
|
langStdMap["CXX"].push_back("98");
|
|
|
|
langStdMap["C"].push_back("11");
|
|
langStdMap["C"].push_back("99");
|
|
langStdMap["C"].push_back("90");
|
|
|
|
langStdMap["CUDA"].push_back("14");
|
|
langStdMap["CUDA"].push_back("11");
|
|
langStdMap["CUDA"].push_back("98");
|
|
}
|
|
|
|
std::string standard(standardProp);
|
|
|
|
std::vector<std::string>& stds = langStdMap[lang];
|
|
|
|
std::vector<std::string>::const_iterator stdIt =
|
|
std::find(stds.begin(), stds.end(), standard);
|
|
if (stdIt == stds.end()) {
|
|
std::string e =
|
|
lang + "_STANDARD is set to invalid value '" + standard + "'";
|
|
this->GetGlobalGenerator()->GetCMakeInstance()->IssueMessage(
|
|
cmake::FATAL_ERROR, e, target->GetBacktrace());
|
|
return;
|
|
}
|
|
|
|
std::vector<std::string>::const_iterator defaultStdIt =
|
|
std::find(stds.begin(), stds.end(), defaultStd);
|
|
if (defaultStdIt == stds.end()) {
|
|
std::string e = "CMAKE_" + lang +
|
|
"_STANDARD_DEFAULT is set to invalid value '" + std::string(defaultStd) +
|
|
"'";
|
|
this->IssueMessage(cmake::INTERNAL_ERROR, e);
|
|
return;
|
|
}
|
|
|
|
// If the standard requested is older than the compiler's default
|
|
// then we need to use a flag to change it. The comparison is
|
|
// greater-or-equal because the standards are stored in backward
|
|
// chronological order.
|
|
if (stdIt >= defaultStdIt) {
|
|
std::string option_flag =
|
|
"CMAKE_" + lang + *stdIt + "_" + type + "_COMPILE_OPTION";
|
|
|
|
std::string const& opt =
|
|
target->Target->GetMakefile()->GetRequiredDefinition(option_flag);
|
|
std::vector<std::string> optVec;
|
|
cmSystemTools::ExpandListArgument(opt, optVec);
|
|
for (std::string const& i : optVec) {
|
|
this->AppendFlagEscape(flags, i);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// The standard requested is at least as new as the compiler's default,
|
|
// and the standard request is not required. Decay to the newest standard
|
|
// for which a flag is defined.
|
|
for (; stdIt < defaultStdIt; ++stdIt) {
|
|
std::string option_flag =
|
|
"CMAKE_" + lang + *stdIt + "_" + type + "_COMPILE_OPTION";
|
|
|
|
if (const char* opt =
|
|
target->Target->GetMakefile()->GetDefinition(option_flag)) {
|
|
std::vector<std::string> optVec;
|
|
cmSystemTools::ExpandListArgument(opt, optVec);
|
|
for (std::string const& i : optVec) {
|
|
this->AppendFlagEscape(flags, i);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void AddVisibilityCompileOption(std::string& flags,
|
|
cmGeneratorTarget const* target,
|
|
cmLocalGenerator* lg,
|
|
const std::string& lang,
|
|
std::string* warnCMP0063)
|
|
{
|
|
std::string compileOption = "CMAKE_" + lang + "_COMPILE_OPTIONS_VISIBILITY";
|
|
const char* opt = lg->GetMakefile()->GetDefinition(compileOption);
|
|
if (!opt) {
|
|
return;
|
|
}
|
|
std::string flagDefine = lang + "_VISIBILITY_PRESET";
|
|
|
|
const char* prop = target->GetProperty(flagDefine);
|
|
if (!prop) {
|
|
return;
|
|
}
|
|
if (warnCMP0063) {
|
|
*warnCMP0063 += " " + flagDefine + "\n";
|
|
return;
|
|
}
|
|
if (strcmp(prop, "hidden") != 0 && strcmp(prop, "default") != 0 &&
|
|
strcmp(prop, "protected") != 0 && strcmp(prop, "internal") != 0) {
|
|
std::ostringstream e;
|
|
e << "Target " << target->GetName() << " uses unsupported value \"" << prop
|
|
<< "\" for " << flagDefine << ".";
|
|
cmSystemTools::Error(e.str().c_str());
|
|
return;
|
|
}
|
|
std::string option = std::string(opt) + prop;
|
|
lg->AppendFlags(flags, option);
|
|
}
|
|
|
|
static void AddInlineVisibilityCompileOption(std::string& flags,
|
|
cmGeneratorTarget const* target,
|
|
cmLocalGenerator* lg,
|
|
std::string* warnCMP0063)
|
|
{
|
|
std::string compileOption =
|
|
"CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN";
|
|
const char* opt = lg->GetMakefile()->GetDefinition(compileOption);
|
|
if (!opt) {
|
|
return;
|
|
}
|
|
|
|
bool prop = target->GetPropertyAsBool("VISIBILITY_INLINES_HIDDEN");
|
|
if (!prop) {
|
|
return;
|
|
}
|
|
if (warnCMP0063) {
|
|
*warnCMP0063 += " VISIBILITY_INLINES_HIDDEN\n";
|
|
return;
|
|
}
|
|
lg->AppendFlags(flags, opt);
|
|
}
|
|
|
|
void cmLocalGenerator::AddVisibilityPresetFlags(
|
|
std::string& flags, cmGeneratorTarget const* target, const std::string& lang)
|
|
{
|
|
if (lang.empty()) {
|
|
return;
|
|
}
|
|
|
|
std::string warnCMP0063;
|
|
std::string* pWarnCMP0063 = nullptr;
|
|
if (target->GetType() != cmStateEnums::SHARED_LIBRARY &&
|
|
target->GetType() != cmStateEnums::MODULE_LIBRARY &&
|
|
!target->IsExecutableWithExports()) {
|
|
switch (target->GetPolicyStatusCMP0063()) {
|
|
case cmPolicies::OLD:
|
|
return;
|
|
case cmPolicies::WARN:
|
|
pWarnCMP0063 = &warnCMP0063;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
AddVisibilityCompileOption(flags, target, this, lang, pWarnCMP0063);
|
|
|
|
if (lang == "CXX") {
|
|
AddInlineVisibilityCompileOption(flags, target, this, pWarnCMP0063);
|
|
}
|
|
|
|
if (!warnCMP0063.empty() && this->WarnCMP0063.insert(target).second) {
|
|
std::ostringstream w;
|
|
/* clang-format off */
|
|
w <<
|
|
cmPolicies::GetPolicyWarning(cmPolicies::CMP0063) << "\n"
|
|
"Target \"" << target->GetName() << "\" of "
|
|
"type \"" << cmState::GetTargetTypeName(target->GetType()) << "\" "
|
|
"has the following visibility properties set for " << lang << ":\n" <<
|
|
warnCMP0063 <<
|
|
"For compatibility CMake is not honoring them for this target.";
|
|
/* clang-format on */
|
|
target->GetLocalGenerator()->GetCMakeInstance()->IssueMessage(
|
|
cmake::AUTHOR_WARNING, w.str(), target->GetBacktrace());
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::AddCMP0018Flags(std::string& flags,
|
|
cmGeneratorTarget const* target,
|
|
std::string const& lang,
|
|
const std::string& config)
|
|
{
|
|
int targetType = target->GetType();
|
|
|
|
bool shared = ((targetType == cmStateEnums::SHARED_LIBRARY) ||
|
|
(targetType == cmStateEnums::MODULE_LIBRARY));
|
|
|
|
if (this->GetShouldUseOldFlags(shared, lang)) {
|
|
this->AddSharedFlags(flags, lang, shared);
|
|
} else {
|
|
if (target->GetType() == cmStateEnums::OBJECT_LIBRARY) {
|
|
if (target->GetPropertyAsBool("POSITION_INDEPENDENT_CODE")) {
|
|
this->AddPositionIndependentFlags(flags, lang, targetType);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (target->GetLinkInterfaceDependentBoolProperty(
|
|
"POSITION_INDEPENDENT_CODE", config)) {
|
|
this->AddPositionIndependentFlags(flags, lang, targetType);
|
|
}
|
|
if (shared) {
|
|
this->AppendFeatureOptions(flags, lang, "DLL");
|
|
}
|
|
}
|
|
}
|
|
|
|
bool cmLocalGenerator::GetShouldUseOldFlags(bool shared,
|
|
const std::string& lang) const
|
|
{
|
|
std::string originalFlags =
|
|
this->GlobalGenerator->GetSharedLibFlagsForLanguage(lang);
|
|
if (shared) {
|
|
std::string flagsVar = "CMAKE_SHARED_LIBRARY_";
|
|
flagsVar += lang;
|
|
flagsVar += "_FLAGS";
|
|
std::string const& flags = this->Makefile->GetSafeDefinition(flagsVar);
|
|
|
|
if (flags != originalFlags) {
|
|
switch (this->GetPolicyStatus(cmPolicies::CMP0018)) {
|
|
case cmPolicies::WARN: {
|
|
std::ostringstream e;
|
|
e << "Variable " << flagsVar
|
|
<< " has been modified. CMake "
|
|
"will ignore the POSITION_INDEPENDENT_CODE target property for "
|
|
"shared libraries and will use the "
|
|
<< flagsVar
|
|
<< " variable "
|
|
"instead. This may cause errors if the original content of "
|
|
<< flagsVar << " was removed.\n"
|
|
<< cmPolicies::GetPolicyWarning(cmPolicies::CMP0018);
|
|
|
|
this->IssueMessage(cmake::AUTHOR_WARNING, e.str());
|
|
CM_FALLTHROUGH;
|
|
}
|
|
case cmPolicies::OLD:
|
|
return true;
|
|
case cmPolicies::REQUIRED_IF_USED:
|
|
case cmPolicies::REQUIRED_ALWAYS:
|
|
case cmPolicies::NEW:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void cmLocalGenerator::AddPositionIndependentFlags(std::string& flags,
|
|
std::string const& lang,
|
|
int targetType)
|
|
{
|
|
std::string picFlags;
|
|
|
|
if (targetType == cmStateEnums::EXECUTABLE) {
|
|
std::string flagsVar = "CMAKE_";
|
|
flagsVar += lang;
|
|
flagsVar += "_COMPILE_OPTIONS_PIE";
|
|
picFlags = this->Makefile->GetSafeDefinition(flagsVar);
|
|
}
|
|
if (picFlags.empty()) {
|
|
std::string flagsVar = "CMAKE_";
|
|
flagsVar += lang;
|
|
flagsVar += "_COMPILE_OPTIONS_PIC";
|
|
picFlags = this->Makefile->GetSafeDefinition(flagsVar);
|
|
}
|
|
if (!picFlags.empty()) {
|
|
std::vector<std::string> options;
|
|
cmSystemTools::ExpandListArgument(picFlags, options);
|
|
for (std::string const& o : options) {
|
|
this->AppendFlagEscape(flags, o);
|
|
}
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::AddConfigVariableFlags(std::string& flags,
|
|
const std::string& var,
|
|
const std::string& config)
|
|
{
|
|
// Add the flags from the variable itself.
|
|
std::string flagsVar = var;
|
|
this->AppendFlags(flags, this->Makefile->GetDefinition(flagsVar));
|
|
// Add the flags from the build-type specific variable.
|
|
if (!config.empty()) {
|
|
flagsVar += "_";
|
|
flagsVar += cmSystemTools::UpperCase(config);
|
|
this->AppendFlags(flags, this->Makefile->GetDefinition(flagsVar));
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::AppendFlags(std::string& flags,
|
|
const std::string& newFlags) const
|
|
{
|
|
if (!newFlags.empty()) {
|
|
if (!flags.empty()) {
|
|
flags += " ";
|
|
}
|
|
flags += newFlags;
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::AppendFlags(std::string& flags,
|
|
const char* newFlags) const
|
|
{
|
|
if (newFlags && *newFlags) {
|
|
this->AppendFlags(flags, std::string(newFlags));
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::AppendFlagEscape(std::string& flags,
|
|
const std::string& rawFlag) const
|
|
{
|
|
this->AppendFlags(flags, this->EscapeForShell(rawFlag));
|
|
}
|
|
|
|
void cmLocalGenerator::AppendIPOLinkerFlags(std::string& flags,
|
|
cmGeneratorTarget* target,
|
|
const std::string& config,
|
|
const std::string& lang)
|
|
{
|
|
if (!target->IsIPOEnabled(lang, config)) {
|
|
return;
|
|
}
|
|
|
|
switch (target->GetType()) {
|
|
case cmStateEnums::EXECUTABLE:
|
|
case cmStateEnums::SHARED_LIBRARY:
|
|
case cmStateEnums::MODULE_LIBRARY:
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
const std::string name = "CMAKE_" + lang + "_LINK_OPTIONS_IPO";
|
|
const char* rawFlagsList = this->Makefile->GetDefinition(name);
|
|
if (rawFlagsList == nullptr) {
|
|
return;
|
|
}
|
|
|
|
std::vector<std::string> flagsList;
|
|
cmSystemTools::ExpandListArgument(rawFlagsList, flagsList);
|
|
for (std::string const& o : flagsList) {
|
|
this->AppendFlagEscape(flags, o);
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::AppendCompileOptions(std::string& options,
|
|
const char* options_list,
|
|
const char* regex) const
|
|
{
|
|
// Short-circuit if there are no options.
|
|
if (!options_list) {
|
|
return;
|
|
}
|
|
|
|
// Expand the list of options.
|
|
std::vector<std::string> options_vec;
|
|
cmSystemTools::ExpandListArgument(options_list, options_vec);
|
|
this->AppendCompileOptions(options, options_vec, regex);
|
|
}
|
|
|
|
void cmLocalGenerator::AppendCompileOptions(
|
|
std::string& options, const std::vector<std::string>& options_vec,
|
|
const char* regex) const
|
|
{
|
|
if (regex != nullptr) {
|
|
// Filter flags upon specified reges.
|
|
cmsys::RegularExpression r(regex);
|
|
|
|
for (std::string const& opt : options_vec) {
|
|
if (r.find(opt)) {
|
|
this->AppendFlagEscape(options, opt);
|
|
}
|
|
}
|
|
} else {
|
|
for (std::string const& opt : options_vec) {
|
|
this->AppendFlagEscape(options, opt);
|
|
}
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::AppendIncludeDirectories(
|
|
std::vector<std::string>& includes, const char* includes_list,
|
|
const cmSourceFile& sourceFile) const
|
|
{
|
|
// Short-circuit if there are no includes.
|
|
if (!includes_list) {
|
|
return;
|
|
}
|
|
|
|
// Expand the list of includes.
|
|
std::vector<std::string> includes_vec;
|
|
cmSystemTools::ExpandListArgument(includes_list, includes_vec);
|
|
this->AppendIncludeDirectories(includes, includes_vec, sourceFile);
|
|
}
|
|
|
|
void cmLocalGenerator::AppendIncludeDirectories(
|
|
std::vector<std::string>& includes,
|
|
const std::vector<std::string>& includes_vec,
|
|
const cmSourceFile& sourceFile) const
|
|
{
|
|
std::unordered_set<std::string> uniqueIncludes;
|
|
|
|
for (const std::string& include : includes_vec) {
|
|
if (!cmSystemTools::FileIsFullPath(include)) {
|
|
std::ostringstream e;
|
|
e << "Found relative path while evaluating include directories of "
|
|
"\""
|
|
<< sourceFile.GetLocation().GetName() << "\":\n \"" << include
|
|
<< "\"\n";
|
|
|
|
this->IssueMessage(cmake::FATAL_ERROR, e.str());
|
|
return;
|
|
}
|
|
|
|
std::string inc = include;
|
|
|
|
if (!cmSystemTools::IsOff(inc)) {
|
|
cmSystemTools::ConvertToUnixSlashes(inc);
|
|
}
|
|
|
|
if (uniqueIncludes.insert(inc).second) {
|
|
includes.push_back(std::move(inc));
|
|
}
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::AppendDefines(std::set<std::string>& defines,
|
|
const char* defines_list) const
|
|
{
|
|
// Short-circuit if there are no definitions.
|
|
if (!defines_list) {
|
|
return;
|
|
}
|
|
|
|
// Expand the list of definitions.
|
|
std::vector<std::string> defines_vec;
|
|
cmSystemTools::ExpandListArgument(defines_list, defines_vec);
|
|
this->AppendDefines(defines, defines_vec);
|
|
}
|
|
|
|
void cmLocalGenerator::AppendDefines(
|
|
std::set<std::string>& defines,
|
|
const std::vector<std::string>& defines_vec) const
|
|
{
|
|
for (std::string const& d : defines_vec) {
|
|
// Skip unsupported definitions.
|
|
if (!this->CheckDefinition(d)) {
|
|
continue;
|
|
}
|
|
defines.insert(d);
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::JoinDefines(const std::set<std::string>& defines,
|
|
std::string& definesString,
|
|
const std::string& lang)
|
|
{
|
|
// Lookup the define flag for the current language.
|
|
std::string dflag = "-D";
|
|
if (!lang.empty()) {
|
|
std::string defineFlagVar = "CMAKE_";
|
|
defineFlagVar += lang;
|
|
defineFlagVar += "_DEFINE_FLAG";
|
|
const char* df = this->Makefile->GetDefinition(defineFlagVar);
|
|
if (df && *df) {
|
|
dflag = df;
|
|
}
|
|
}
|
|
|
|
std::set<std::string>::const_iterator defineIt = defines.begin();
|
|
const std::set<std::string>::const_iterator defineEnd = defines.end();
|
|
const char* itemSeparator = definesString.empty() ? "" : " ";
|
|
for (; defineIt != defineEnd; ++defineIt) {
|
|
// Append the definition with proper escaping.
|
|
std::string def = dflag;
|
|
if (this->GetState()->UseWatcomWMake()) {
|
|
// The Watcom compiler does its own command line parsing instead
|
|
// of using the windows shell rules. Definitions are one of
|
|
// -DNAME
|
|
// -DNAME=<cpp-token>
|
|
// -DNAME="c-string with spaces and other characters(?@#$)"
|
|
//
|
|
// Watcom will properly parse each of these cases from the
|
|
// command line without any escapes. However we still have to
|
|
// get the '$' and '#' characters through WMake as '$$' and
|
|
// '$#'.
|
|
for (const char* c = defineIt->c_str(); *c; ++c) {
|
|
if (*c == '$' || *c == '#') {
|
|
def += '$';
|
|
}
|
|
def += *c;
|
|
}
|
|
} else {
|
|
// Make the definition appear properly on the command line. Use
|
|
// -DNAME="value" instead of -D"NAME=value" for historical reasons.
|
|
std::string::size_type eq = defineIt->find("=");
|
|
def += defineIt->substr(0, eq);
|
|
if (eq != std::string::npos) {
|
|
def += "=";
|
|
def += this->EscapeForShell(defineIt->c_str() + eq + 1, true);
|
|
}
|
|
}
|
|
definesString += itemSeparator;
|
|
itemSeparator = " ";
|
|
definesString += def;
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::AppendFeatureOptions(std::string& flags,
|
|
const std::string& lang,
|
|
const char* feature)
|
|
{
|
|
std::string optVar = "CMAKE_";
|
|
optVar += lang;
|
|
optVar += "_COMPILE_OPTIONS_";
|
|
optVar += feature;
|
|
if (const char* optionList = this->Makefile->GetDefinition(optVar)) {
|
|
std::vector<std::string> options;
|
|
cmSystemTools::ExpandListArgument(optionList, options);
|
|
for (std::string const& o : options) {
|
|
this->AppendFlagEscape(flags, o);
|
|
}
|
|
}
|
|
}
|
|
|
|
const char* cmLocalGenerator::GetFeature(const std::string& feature,
|
|
const std::string& config)
|
|
{
|
|
std::string featureName = feature;
|
|
// TODO: Define accumulation policy for features (prepend, append, replace).
|
|
// Currently we always replace.
|
|
if (!config.empty()) {
|
|
featureName += "_";
|
|
featureName += cmSystemTools::UpperCase(config);
|
|
}
|
|
cmStateSnapshot snp = this->StateSnapshot;
|
|
while (snp.IsValid()) {
|
|
if (const char* value = snp.GetDirectory().GetProperty(featureName)) {
|
|
return value;
|
|
}
|
|
snp = snp.GetBuildsystemDirectoryParent();
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
std::string cmLocalGenerator::GetProjectName() const
|
|
{
|
|
return this->StateSnapshot.GetProjectName();
|
|
}
|
|
|
|
std::string cmLocalGenerator::ConstructComment(
|
|
cmCustomCommandGenerator const& ccg, const char* default_comment)
|
|
{
|
|
// Check for a comment provided with the command.
|
|
if (ccg.GetComment()) {
|
|
return ccg.GetComment();
|
|
}
|
|
|
|
// Construct a reasonable default comment if possible.
|
|
if (!ccg.GetOutputs().empty()) {
|
|
std::string comment;
|
|
comment = "Generating ";
|
|
const char* sep = "";
|
|
std::string currentBinaryDir = this->GetCurrentBinaryDirectory();
|
|
for (std::string const& o : ccg.GetOutputs()) {
|
|
comment += sep;
|
|
comment += this->ConvertToRelativePath(currentBinaryDir, o);
|
|
sep = ", ";
|
|
}
|
|
return comment;
|
|
}
|
|
|
|
// Otherwise use the provided default.
|
|
return default_comment;
|
|
}
|
|
|
|
class cmInstallTargetGeneratorLocal : public cmInstallTargetGenerator
|
|
{
|
|
public:
|
|
cmInstallTargetGeneratorLocal(cmLocalGenerator* lg, std::string const& t,
|
|
const char* dest, bool implib)
|
|
: cmInstallTargetGenerator(
|
|
t, dest, implib, "", std::vector<std::string>(), "Unspecified",
|
|
cmInstallGenerator::SelectMessageLevel(lg->GetMakefile()), false,
|
|
false)
|
|
{
|
|
this->Compute(lg);
|
|
}
|
|
};
|
|
|
|
void cmLocalGenerator::GenerateTargetInstallRules(
|
|
std::ostream& os, const std::string& config,
|
|
std::vector<std::string> const& configurationTypes)
|
|
{
|
|
// Convert the old-style install specification from each target to
|
|
// an install generator and run it.
|
|
const std::vector<cmGeneratorTarget*>& tgts = this->GetGeneratorTargets();
|
|
for (cmGeneratorTarget* l : tgts) {
|
|
if (l->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
|
|
continue;
|
|
}
|
|
|
|
// Include the user-specified pre-install script for this target.
|
|
if (const char* preinstall = l->GetProperty("PRE_INSTALL_SCRIPT")) {
|
|
cmInstallScriptGenerator g(preinstall, false, nullptr, false);
|
|
g.Generate(os, config, configurationTypes);
|
|
}
|
|
|
|
// Install this target if a destination is given.
|
|
if (!l->Target->GetInstallPath().empty()) {
|
|
// Compute the full install destination. Note that converting
|
|
// to unix slashes also removes any trailing slash.
|
|
// We also skip over the leading slash given by the user.
|
|
std::string destination = l->Target->GetInstallPath().substr(1);
|
|
cmSystemTools::ConvertToUnixSlashes(destination);
|
|
if (destination.empty()) {
|
|
destination = ".";
|
|
}
|
|
|
|
// Generate the proper install generator for this target type.
|
|
switch (l->GetType()) {
|
|
case cmStateEnums::EXECUTABLE:
|
|
case cmStateEnums::STATIC_LIBRARY:
|
|
case cmStateEnums::MODULE_LIBRARY: {
|
|
// Use a target install generator.
|
|
cmInstallTargetGeneratorLocal g(this, l->GetName(),
|
|
destination.c_str(), false);
|
|
g.Generate(os, config, configurationTypes);
|
|
} break;
|
|
case cmStateEnums::SHARED_LIBRARY: {
|
|
#if defined(_WIN32) || defined(__CYGWIN__)
|
|
// Special code to handle DLL. Install the import library
|
|
// to the normal destination and the DLL to the runtime
|
|
// destination.
|
|
cmInstallTargetGeneratorLocal g1(this, l->GetName(),
|
|
destination.c_str(), true);
|
|
g1.Generate(os, config, configurationTypes);
|
|
// We also skip over the leading slash given by the user.
|
|
destination = l->Target->GetRuntimeInstallPath().substr(1);
|
|
cmSystemTools::ConvertToUnixSlashes(destination);
|
|
cmInstallTargetGeneratorLocal g2(this, l->GetName(),
|
|
destination.c_str(), false);
|
|
g2.Generate(os, config, configurationTypes);
|
|
#else
|
|
// Use a target install generator.
|
|
cmInstallTargetGeneratorLocal g(this, l->GetName(),
|
|
destination.c_str(), false);
|
|
g.Generate(os, config, configurationTypes);
|
|
#endif
|
|
} break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Include the user-specified post-install script for this target.
|
|
if (const char* postinstall = l->GetProperty("POST_INSTALL_SCRIPT")) {
|
|
cmInstallScriptGenerator g(postinstall, false, nullptr, false);
|
|
g.Generate(os, config, configurationTypes);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if defined(CM_LG_ENCODE_OBJECT_NAMES)
|
|
static bool cmLocalGeneratorShortenObjectName(std::string& objName,
|
|
std::string::size_type max_len)
|
|
{
|
|
// Replace the beginning of the path portion of the object name with
|
|
// its own md5 sum.
|
|
std::string::size_type pos =
|
|
objName.find('/', objName.size() - max_len + 32);
|
|
if (pos != std::string::npos) {
|
|
cmCryptoHash md5(cmCryptoHash::AlgoMD5);
|
|
std::string md5name = md5.HashString(objName.substr(0, pos));
|
|
md5name += objName.substr(pos);
|
|
objName = md5name;
|
|
|
|
// The object name is now short enough.
|
|
return true;
|
|
}
|
|
// The object name could not be shortened enough.
|
|
return false;
|
|
}
|
|
|
|
bool cmLocalGeneratorCheckObjectName(std::string& objName,
|
|
std::string::size_type dir_len,
|
|
std::string::size_type max_total_len)
|
|
{
|
|
// Enforce the maximum file name length if possible.
|
|
std::string::size_type max_obj_len = max_total_len;
|
|
if (dir_len < max_total_len) {
|
|
max_obj_len = max_total_len - dir_len;
|
|
if (objName.size() > max_obj_len) {
|
|
// The current object file name is too long. Try to shorten it.
|
|
return cmLocalGeneratorShortenObjectName(objName, max_obj_len);
|
|
}
|
|
// The object file name is short enough.
|
|
return true;
|
|
}
|
|
// The build directory in which the object will be stored is
|
|
// already too deep.
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
std::string& cmLocalGenerator::CreateSafeUniqueObjectFileName(
|
|
const std::string& sin, std::string const& dir_max)
|
|
{
|
|
// Look for an existing mapped name for this object file.
|
|
std::map<std::string, std::string>::iterator it =
|
|
this->UniqueObjectNamesMap.find(sin);
|
|
|
|
// If no entry exists create one.
|
|
if (it == this->UniqueObjectNamesMap.end()) {
|
|
// Start with the original name.
|
|
std::string ssin = sin;
|
|
|
|
// Avoid full paths by removing leading slashes.
|
|
ssin.erase(0, ssin.find_first_not_of('/'));
|
|
|
|
// Avoid full paths by removing colons.
|
|
std::replace(ssin.begin(), ssin.end(), ':', '_');
|
|
|
|
// Avoid relative paths that go up the tree.
|
|
cmSystemTools::ReplaceString(ssin, "../", "__/");
|
|
|
|
// Avoid spaces.
|
|
std::replace(ssin.begin(), ssin.end(), ' ', '_');
|
|
|
|
// Mangle the name if necessary.
|
|
if (this->Makefile->IsOn("CMAKE_MANGLE_OBJECT_FILE_NAMES")) {
|
|
bool done;
|
|
int cc = 0;
|
|
char rpstr[100];
|
|
sprintf(rpstr, "_p_");
|
|
cmSystemTools::ReplaceString(ssin, "+", rpstr);
|
|
std::string sssin = sin;
|
|
do {
|
|
done = true;
|
|
for (it = this->UniqueObjectNamesMap.begin();
|
|
it != this->UniqueObjectNamesMap.end(); ++it) {
|
|
if (it->second == ssin) {
|
|
done = false;
|
|
}
|
|
}
|
|
if (done) {
|
|
break;
|
|
}
|
|
sssin = ssin;
|
|
cmSystemTools::ReplaceString(ssin, "_p_", rpstr);
|
|
sprintf(rpstr, "_p%d_", cc++);
|
|
} while (!done);
|
|
}
|
|
|
|
#if defined(CM_LG_ENCODE_OBJECT_NAMES)
|
|
if (!cmLocalGeneratorCheckObjectName(ssin, dir_max.size(),
|
|
this->ObjectPathMax)) {
|
|
// Warn if this is the first time the path has been seen.
|
|
if (this->ObjectMaxPathViolations.insert(dir_max).second) {
|
|
std::ostringstream m;
|
|
/* clang-format off */
|
|
m << "The object file directory\n"
|
|
<< " " << dir_max << "\n"
|
|
<< "has " << dir_max.size() << " characters. "
|
|
<< "The maximum full path to an object file is "
|
|
<< this->ObjectPathMax << " characters "
|
|
<< "(see CMAKE_OBJECT_PATH_MAX). "
|
|
<< "Object file\n"
|
|
<< " " << ssin << "\n"
|
|
<< "cannot be safely placed under this directory. "
|
|
<< "The build may not work correctly.";
|
|
/* clang-format on */
|
|
this->IssueMessage(cmake::WARNING, m.str());
|
|
}
|
|
}
|
|
#else
|
|
(void)dir_max;
|
|
#endif
|
|
|
|
// Insert the newly mapped object file name.
|
|
std::map<std::string, std::string>::value_type e(sin, ssin);
|
|
it = this->UniqueObjectNamesMap.insert(e).first;
|
|
}
|
|
|
|
// Return the map entry.
|
|
return it->second;
|
|
}
|
|
|
|
void cmLocalGenerator::ComputeObjectFilenames(
|
|
std::map<cmSourceFile const*, std::string>& /*unused*/,
|
|
cmGeneratorTarget const* /*unused*/)
|
|
{
|
|
}
|
|
|
|
bool cmLocalGenerator::IsWindowsShell() const
|
|
{
|
|
return this->GetState()->UseWindowsShell();
|
|
}
|
|
|
|
bool cmLocalGenerator::IsWatcomWMake() const
|
|
{
|
|
return this->GetState()->UseWatcomWMake();
|
|
}
|
|
|
|
bool cmLocalGenerator::IsMinGWMake() const
|
|
{
|
|
return this->GetState()->UseMinGWMake();
|
|
}
|
|
|
|
bool cmLocalGenerator::IsNMake() const
|
|
{
|
|
return this->GetState()->UseNMake();
|
|
}
|
|
|
|
std::string cmLocalGenerator::GetObjectFileNameWithoutTarget(
|
|
const cmSourceFile& source, std::string const& dir_max,
|
|
bool* hasSourceExtension, char const* customOutputExtension)
|
|
{
|
|
// Construct the object file name using the full path to the source
|
|
// file which is its only unique identification.
|
|
std::string const& fullPath = source.GetFullPath();
|
|
|
|
// Try referencing the source relative to the source tree.
|
|
std::string relFromSource =
|
|
this->ConvertToRelativePath(this->GetCurrentSourceDirectory(), fullPath);
|
|
assert(!relFromSource.empty());
|
|
bool relSource = !cmSystemTools::FileIsFullPath(relFromSource);
|
|
bool subSource = relSource && relFromSource[0] != '.';
|
|
|
|
// Try referencing the source relative to the binary tree.
|
|
std::string relFromBinary =
|
|
this->ConvertToRelativePath(this->GetCurrentBinaryDirectory(), fullPath);
|
|
assert(!relFromBinary.empty());
|
|
bool relBinary = !cmSystemTools::FileIsFullPath(relFromBinary);
|
|
bool subBinary = relBinary && relFromBinary[0] != '.';
|
|
|
|
// Select a nice-looking reference to the source file to construct
|
|
// the object file name.
|
|
std::string objectName;
|
|
if ((relSource && !relBinary) || (subSource && !subBinary)) {
|
|
objectName = relFromSource;
|
|
} else if ((relBinary && !relSource) || (subBinary && !subSource)) {
|
|
objectName = relFromBinary;
|
|
} else if (relFromBinary.length() < relFromSource.length()) {
|
|
objectName = relFromBinary;
|
|
} else {
|
|
objectName = relFromSource;
|
|
}
|
|
|
|
// if it is still a full path check for the try compile case
|
|
// try compile never have in source sources, and should not
|
|
// have conflicting source file names in the same target
|
|
if (cmSystemTools::FileIsFullPath(objectName)) {
|
|
if (this->GetGlobalGenerator()->GetCMakeInstance()->GetIsInTryCompile()) {
|
|
objectName = cmSystemTools::GetFilenameName(source.GetFullPath());
|
|
}
|
|
}
|
|
|
|
// Replace the original source file extension with the object file
|
|
// extension.
|
|
bool keptSourceExtension = true;
|
|
if (!source.GetPropertyAsBool("KEEP_EXTENSION")) {
|
|
// Decide whether this language wants to replace the source
|
|
// extension with the object extension. For CMake 2.4
|
|
// compatibility do this by default.
|
|
bool replaceExt = this->NeedBackwardsCompatibility_2_4();
|
|
if (!replaceExt) {
|
|
std::string lang = source.GetLanguage();
|
|
if (!lang.empty()) {
|
|
std::string repVar = "CMAKE_";
|
|
repVar += lang;
|
|
repVar += "_OUTPUT_EXTENSION_REPLACE";
|
|
replaceExt = this->Makefile->IsOn(repVar);
|
|
}
|
|
}
|
|
|
|
// Remove the source extension if it is to be replaced.
|
|
if (replaceExt || customOutputExtension) {
|
|
keptSourceExtension = false;
|
|
std::string::size_type dot_pos = objectName.rfind('.');
|
|
if (dot_pos != std::string::npos) {
|
|
objectName = objectName.substr(0, dot_pos);
|
|
}
|
|
}
|
|
|
|
// Store the new extension.
|
|
if (customOutputExtension) {
|
|
objectName += customOutputExtension;
|
|
} else {
|
|
objectName += this->GlobalGenerator->GetLanguageOutputExtension(source);
|
|
}
|
|
}
|
|
if (hasSourceExtension) {
|
|
*hasSourceExtension = keptSourceExtension;
|
|
}
|
|
|
|
// Convert to a safe name.
|
|
return this->CreateSafeUniqueObjectFileName(objectName, dir_max);
|
|
}
|
|
|
|
std::string cmLocalGenerator::GetSourceFileLanguage(const cmSourceFile& source)
|
|
{
|
|
return source.GetLanguage();
|
|
}
|
|
|
|
cmake* cmLocalGenerator::GetCMakeInstance() const
|
|
{
|
|
return this->GlobalGenerator->GetCMakeInstance();
|
|
}
|
|
|
|
std::string const& cmLocalGenerator::GetSourceDirectory() const
|
|
{
|
|
return this->GetCMakeInstance()->GetHomeDirectory();
|
|
}
|
|
|
|
std::string const& cmLocalGenerator::GetBinaryDirectory() const
|
|
{
|
|
return this->GetCMakeInstance()->GetHomeOutputDirectory();
|
|
}
|
|
|
|
std::string const& cmLocalGenerator::GetCurrentBinaryDirectory() const
|
|
{
|
|
return this->StateSnapshot.GetDirectory().GetCurrentBinary();
|
|
}
|
|
|
|
std::string const& cmLocalGenerator::GetCurrentSourceDirectory() const
|
|
{
|
|
return this->StateSnapshot.GetDirectory().GetCurrentSource();
|
|
}
|
|
|
|
std::string cmLocalGenerator::GetTargetDirectory(
|
|
const cmGeneratorTarget* /*unused*/) const
|
|
{
|
|
cmSystemTools::Error("GetTargetDirectory"
|
|
" called on cmLocalGenerator");
|
|
return "";
|
|
}
|
|
|
|
KWIML_INT_uint64_t cmLocalGenerator::GetBackwardsCompatibility()
|
|
{
|
|
// The computed version may change until the project is fully
|
|
// configured.
|
|
if (!this->BackwardsCompatibilityFinal) {
|
|
unsigned int major = 0;
|
|
unsigned int minor = 0;
|
|
unsigned int patch = 0;
|
|
if (const char* value =
|
|
this->Makefile->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY")) {
|
|
switch (sscanf(value, "%u.%u.%u", &major, &minor, &patch)) {
|
|
case 2:
|
|
patch = 0;
|
|
break;
|
|
case 1:
|
|
minor = 0;
|
|
patch = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
this->BackwardsCompatibility = CMake_VERSION_ENCODE(major, minor, patch);
|
|
this->BackwardsCompatibilityFinal = true;
|
|
}
|
|
|
|
return this->BackwardsCompatibility;
|
|
}
|
|
|
|
bool cmLocalGenerator::NeedBackwardsCompatibility_2_4()
|
|
{
|
|
// Check the policy to decide whether to pay attention to this
|
|
// variable.
|
|
switch (this->GetPolicyStatus(cmPolicies::CMP0001)) {
|
|
case cmPolicies::WARN:
|
|
// WARN is just OLD without warning because user code does not
|
|
// always affect whether this check is done.
|
|
case cmPolicies::OLD:
|
|
// Old behavior is to check the variable.
|
|
break;
|
|
case cmPolicies::NEW:
|
|
// New behavior is to ignore the variable.
|
|
return false;
|
|
case cmPolicies::REQUIRED_IF_USED:
|
|
case cmPolicies::REQUIRED_ALWAYS:
|
|
// This will never be the case because the only way to require
|
|
// the setting is to require the user to specify version policy
|
|
// 2.6 or higher. Once we add that requirement then this whole
|
|
// method can be removed anyway.
|
|
return false;
|
|
}
|
|
|
|
// Compatibility is needed if CMAKE_BACKWARDS_COMPATIBILITY is set
|
|
// equal to or lower than the given version.
|
|
KWIML_INT_uint64_t actual_compat = this->GetBackwardsCompatibility();
|
|
return (actual_compat && actual_compat <= CMake_VERSION_ENCODE(2, 4, 255));
|
|
}
|
|
|
|
cmPolicies::PolicyStatus cmLocalGenerator::GetPolicyStatus(
|
|
cmPolicies::PolicyID id) const
|
|
{
|
|
return this->Makefile->GetPolicyStatus(id);
|
|
}
|
|
|
|
bool cmLocalGenerator::CheckDefinition(std::string const& define) const
|
|
{
|
|
// Many compilers do not support -DNAME(arg)=sdf so we disable it.
|
|
std::string::size_type pos = define.find_first_of("(=");
|
|
if (pos != std::string::npos) {
|
|
if (define[pos] == '(') {
|
|
std::ostringstream e;
|
|
/* clang-format off */
|
|
e << "WARNING: Function-style preprocessor definitions may not be "
|
|
<< "passed on the compiler command line because many compilers "
|
|
<< "do not support it.\n"
|
|
<< "CMake is dropping a preprocessor definition: " << define << "\n"
|
|
<< "Consider defining the macro in a (configured) header file.\n";
|
|
/* clang-format on */
|
|
cmSystemTools::Message(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Many compilers do not support # in the value so we disable it.
|
|
if (define.find_first_of('#') != std::string::npos) {
|
|
std::ostringstream e;
|
|
/* clang-format off */
|
|
e << "WARNING: Preprocessor definitions containing '#' may not be "
|
|
<< "passed on the compiler command line because many compilers "
|
|
<< "do not support it.\n"
|
|
<< "CMake is dropping a preprocessor definition: " << define << "\n"
|
|
<< "Consider defining the macro in a (configured) header file.\n";
|
|
/* clang-format on */
|
|
cmSystemTools::Message(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// Assume it is supported.
|
|
return true;
|
|
}
|
|
|
|
static void cmLGInfoProp(cmMakefile* mf, cmGeneratorTarget* target,
|
|
const std::string& prop)
|
|
{
|
|
if (const char* val = target->GetProperty(prop)) {
|
|
mf->AddDefinition(prop, val);
|
|
}
|
|
}
|
|
|
|
void cmLocalGenerator::GenerateAppleInfoPList(cmGeneratorTarget* target,
|
|
const std::string& targetName,
|
|
const char* fname)
|
|
{
|
|
// Find the Info.plist template.
|
|
const char* in = target->GetProperty("MACOSX_BUNDLE_INFO_PLIST");
|
|
std::string inFile = (in && *in) ? in : "MacOSXBundleInfo.plist.in";
|
|
if (!cmSystemTools::FileIsFullPath(inFile)) {
|
|
std::string inMod = this->Makefile->GetModulesFile(inFile.c_str());
|
|
if (!inMod.empty()) {
|
|
inFile = inMod;
|
|
}
|
|
}
|
|
if (!cmSystemTools::FileExists(inFile, true)) {
|
|
std::ostringstream e;
|
|
e << "Target " << target->GetName() << " Info.plist template \"" << inFile
|
|
<< "\" could not be found.";
|
|
cmSystemTools::Error(e.str().c_str());
|
|
return;
|
|
}
|
|
|
|
// Convert target properties to variables in an isolated makefile
|
|
// scope to configure the file. If properties are set they will
|
|
// override user make variables. If not the configuration will fall
|
|
// back to the directory-level values set by the user.
|
|
cmMakefile* mf = this->Makefile;
|
|
cmMakefile::ScopePushPop varScope(mf);
|
|
mf->AddDefinition("MACOSX_BUNDLE_EXECUTABLE_NAME", targetName.c_str());
|
|
cmLGInfoProp(mf, target, "MACOSX_BUNDLE_INFO_STRING");
|
|
cmLGInfoProp(mf, target, "MACOSX_BUNDLE_ICON_FILE");
|
|
cmLGInfoProp(mf, target, "MACOSX_BUNDLE_GUI_IDENTIFIER");
|
|
cmLGInfoProp(mf, target, "MACOSX_BUNDLE_LONG_VERSION_STRING");
|
|
cmLGInfoProp(mf, target, "MACOSX_BUNDLE_BUNDLE_NAME");
|
|
cmLGInfoProp(mf, target, "MACOSX_BUNDLE_SHORT_VERSION_STRING");
|
|
cmLGInfoProp(mf, target, "MACOSX_BUNDLE_BUNDLE_VERSION");
|
|
cmLGInfoProp(mf, target, "MACOSX_BUNDLE_COPYRIGHT");
|
|
mf->ConfigureFile(inFile.c_str(), fname, false, false, false);
|
|
}
|
|
|
|
void cmLocalGenerator::GenerateFrameworkInfoPList(
|
|
cmGeneratorTarget* target, const std::string& targetName, const char* fname)
|
|
{
|
|
// Find the Info.plist template.
|
|
const char* in = target->GetProperty("MACOSX_FRAMEWORK_INFO_PLIST");
|
|
std::string inFile = (in && *in) ? in : "MacOSXFrameworkInfo.plist.in";
|
|
if (!cmSystemTools::FileIsFullPath(inFile)) {
|
|
std::string inMod = this->Makefile->GetModulesFile(inFile.c_str());
|
|
if (!inMod.empty()) {
|
|
inFile = inMod;
|
|
}
|
|
}
|
|
if (!cmSystemTools::FileExists(inFile, true)) {
|
|
std::ostringstream e;
|
|
e << "Target " << target->GetName() << " Info.plist template \"" << inFile
|
|
<< "\" could not be found.";
|
|
cmSystemTools::Error(e.str().c_str());
|
|
return;
|
|
}
|
|
|
|
// Convert target properties to variables in an isolated makefile
|
|
// scope to configure the file. If properties are set they will
|
|
// override user make variables. If not the configuration will fall
|
|
// back to the directory-level values set by the user.
|
|
cmMakefile* mf = this->Makefile;
|
|
cmMakefile::ScopePushPop varScope(mf);
|
|
mf->AddDefinition("MACOSX_FRAMEWORK_NAME", targetName.c_str());
|
|
cmLGInfoProp(mf, target, "MACOSX_FRAMEWORK_ICON_FILE");
|
|
cmLGInfoProp(mf, target, "MACOSX_FRAMEWORK_IDENTIFIER");
|
|
cmLGInfoProp(mf, target, "MACOSX_FRAMEWORK_SHORT_VERSION_STRING");
|
|
cmLGInfoProp(mf, target, "MACOSX_FRAMEWORK_BUNDLE_VERSION");
|
|
mf->ConfigureFile(inFile.c_str(), fname, false, false, false);
|
|
}
|