blob: 785f3566798bf4f208552d0461ae814e76b1e2ed [file] [log] [blame]
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmStandardLevelResolver.h"
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <sstream>
#include <stdexcept>
#include <unordered_map>
#include <utility>
#include <vector>
#include <cm/iterator>
#include <cmext/algorithm>
#include "cmGeneratorExpression.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmPolicies.h"
#include "cmStringAlgorithms.h"
#include "cmTarget.h"
#include "cmValue.h"
#include "cmake.h"
namespace {
#define FEATURE_STRING(F) , #F
const char* const C_FEATURES[] = { nullptr FOR_EACH_C_FEATURE(
FEATURE_STRING) };
const char* const CXX_FEATURES[] = { nullptr FOR_EACH_CXX_FEATURE(
FEATURE_STRING) };
const char* const CUDA_FEATURES[] = { nullptr FOR_EACH_CUDA_FEATURE(
FEATURE_STRING) };
const char* const HIP_FEATURES[] = { nullptr FOR_EACH_HIP_FEATURE(
FEATURE_STRING) };
#undef FEATURE_STRING
struct StandardNeeded
{
int index;
int value;
};
int ParseStd(std::string const& level)
{
try {
return std::stoi(level);
} catch (std::invalid_argument&) {
// Fall through to use an invalid value.
}
return -1;
}
struct StandardLevelComputer
{
explicit StandardLevelComputer(std::string lang, std::vector<int> levels,
std::vector<std::string> levelsStr)
: Language(std::move(lang))
, Levels(std::move(levels))
, LevelsAsStrings(std::move(levelsStr))
{
assert(this->Levels.size() == this->LevelsAsStrings.size());
}
std::string GetCompileOptionDef(cmMakefile* makefile,
cmGeneratorTarget const* target,
std::string const& config) const
{
const auto& stds = this->Levels;
const auto& stdsStrings = this->LevelsAsStrings;
cmValue defaultStd = makefile->GetDefinition(
cmStrCat("CMAKE_", this->Language, "_STANDARD_DEFAULT"));
if (!cmNonempty(defaultStd)) {
// this compiler has no notion of language standard levels
return std::string{};
}
cmPolicies::PolicyStatus const cmp0128{ makefile->GetPolicyStatus(
cmPolicies::CMP0128) };
bool const defaultExt{ cmIsOn(*makefile->GetDefinition(
cmStrCat("CMAKE_", this->Language, "_EXTENSIONS_DEFAULT"))) };
bool ext = true;
if (cmp0128 == cmPolicies::NEW) {
ext = defaultExt;
}
if (cmValue extPropValue = target->GetLanguageExtensions(this->Language)) {
ext = cmIsOn(*extPropValue);
}
std::string const type{ ext ? "EXTENSION" : "STANDARD" };
cmValue standardProp = target->GetLanguageStandard(this->Language, config);
if (!standardProp) {
if (cmp0128 == cmPolicies::NEW) {
// Add extension flag if compiler's default doesn't match.
if (ext != defaultExt) {
return cmStrCat("CMAKE_", this->Language, *defaultStd, "_", type,
"_COMPILE_OPTION");
}
} else {
if (cmp0128 == cmPolicies::WARN &&
makefile->PolicyOptionalWarningEnabled(
"CMAKE_POLICY_WARNING_CMP0128") &&
ext != defaultExt) {
const char* state{};
if (ext) {
if (!makefile->GetDefinition(cmStrCat(
"CMAKE_", this->Language, "_EXTENSION_COMPILE_OPTION"))) {
state = "enabled";
}
} else {
state = "disabled";
}
if (state) {
makefile->IssueMessage(
MessageType::AUTHOR_WARNING,
cmStrCat(cmPolicies::GetPolicyWarning(cmPolicies::CMP0128),
"\nFor compatibility with older versions of CMake, "
"compiler extensions won't be ",
state, "."));
}
}
if (ext) {
return cmStrCat("CMAKE_", this->Language,
"_EXTENSION_COMPILE_OPTION");
}
}
return std::string{};
}
if (target->GetLanguageStandardRequired(this->Language)) {
std::string option_flag = cmStrCat(
"CMAKE_", this->Language, *standardProp, "_", type, "_COMPILE_OPTION");
cmValue opt = target->Target->GetMakefile()->GetDefinition(option_flag);
if (!opt) {
std::ostringstream e;
e << "Target \"" << target->GetName()
<< "\" requires the language "
"dialect \""
<< this->Language << *standardProp << "\" "
<< (ext ? "(with compiler extensions)" : "")
<< ". But the current compiler \""
<< makefile->GetSafeDefinition("CMAKE_" + this->Language +
"_COMPILER_ID")
<< "\" does not support this, or "
"CMake does not know the flags to enable it.";
makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
}
return option_flag;
}
// If the request matches the compiler's defaults we don't need to add
// anything.
if (*standardProp == *defaultStd && ext == defaultExt) {
if (cmp0128 == cmPolicies::NEW) {
return std::string{};
}
if (cmp0128 == cmPolicies::WARN &&
makefile->PolicyOptionalWarningEnabled(
"CMAKE_POLICY_WARNING_CMP0128")) {
makefile->IssueMessage(
MessageType::AUTHOR_WARNING,
cmStrCat(cmPolicies::GetPolicyWarning(cmPolicies::CMP0128),
"\nFor compatibility with older versions of CMake, "
"unnecessary flags for language standard or compiler "
"extensions may be added."));
}
}
std::string standardStr(*standardProp);
if (this->Language == "CUDA" && standardStr == "98") {
standardStr = "03";
}
auto stdIt =
std::find(cm::cbegin(stds), cm::cend(stds), ParseStd(standardStr));
if (stdIt == cm::cend(stds)) {
std::string e =
cmStrCat(this->Language, "_STANDARD is set to invalid value '",
standardStr, "'");
makefile->GetCMakeInstance()->IssueMessage(MessageType::FATAL_ERROR, e,
target->GetBacktrace());
return std::string{};
}
auto defaultStdIt =
std::find(cm::cbegin(stds), cm::cend(stds), ParseStd(*defaultStd));
if (defaultStdIt == cm::cend(stds)) {
std::string e = cmStrCat("CMAKE_", this->Language,
"_STANDARD_DEFAULT is set to invalid value '",
*defaultStd, "'");
makefile->IssueMessage(MessageType::INTERNAL_ERROR, e);
return std::string{};
}
// If the standard requested is older than the compiler's default or the
// extension mode doesn't match then we need to use a flag.
if ((cmp0128 != cmPolicies::NEW && stdIt <= defaultStdIt) ||
(cmp0128 == cmPolicies::NEW &&
(stdIt < defaultStdIt || ext != defaultExt))) {
auto offset = std::distance(cm::cbegin(stds), stdIt);
return cmStrCat("CMAKE_", this->Language, stdsStrings[offset], "_", type,
"_COMPILE_OPTION");
}
// The compiler's default is at least as new as the requested standard,
// and the requested standard is not required. Decay to the newest
// standard for which a flag is defined.
for (; defaultStdIt < stdIt; --stdIt) {
auto offset = std::distance(cm::cbegin(stds), stdIt);
std::string option_flag =
cmStrCat("CMAKE_", this->Language, stdsStrings[offset], "_", type,
"_COMPILE_OPTION");
if (target->Target->GetMakefile()->GetDefinition(option_flag)) {
return option_flag;
}
}
return std::string{};
}
bool GetNewRequiredStandard(cmMakefile* makefile,
std::string const& targetName,
const std::string& feature,
cmValue currentLangStandardValue,
std::string& newRequiredStandard,
std::string* error) const
{
if (currentLangStandardValue) {
newRequiredStandard = *currentLangStandardValue;
} else {
newRequiredStandard.clear();
}
auto needed = this->HighestStandardNeeded(makefile, feature);
cmValue existingStandard = currentLangStandardValue;
if (!existingStandard) {
cmValue defaultStandard = makefile->GetDefinition(
cmStrCat("CMAKE_", this->Language, "_STANDARD_DEFAULT"));
if (cmNonempty(defaultStandard)) {
existingStandard = defaultStandard;
}
}
auto existingLevelIter = cm::cend(this->Levels);
if (existingStandard) {
existingLevelIter =
std::find(cm::cbegin(this->Levels), cm::cend(this->Levels),
ParseStd(*existingStandard));
if (existingLevelIter == cm::cend(this->Levels)) {
const std::string e =
cmStrCat("The ", this->Language, "_STANDARD property on target \"",
targetName, "\" contained an invalid value: \"",
*existingStandard, "\".");
if (error) {
*error = e;
} else {
makefile->IssueMessage(MessageType::FATAL_ERROR, e);
}
return false;
}
}
if (needed.index != -1) {
// Ensure the C++ language level is high enough to support
// the needed C++ features.
if (existingLevelIter == cm::cend(this->Levels) ||
existingLevelIter < this->Levels.begin() + needed.index) {
newRequiredStandard = this->LevelsAsStrings[needed.index];
}
}
return true;
}
bool HaveStandardAvailable(cmMakefile* makefile,
cmGeneratorTarget const* target,
std::string const& config,
std::string const& feature) const
{
cmValue defaultStandard = makefile->GetDefinition(
cmStrCat("CMAKE_", this->Language, "_STANDARD_DEFAULT"));
if (!defaultStandard) {
makefile->IssueMessage(
MessageType::INTERNAL_ERROR,
cmStrCat("CMAKE_", this->Language,
"_STANDARD_DEFAULT is not set. COMPILE_FEATURES support "
"not fully configured for this compiler."));
// Return true so the caller does not try to lookup the default standard.
return true;
}
// convert defaultStandard to an integer
if (std::find(cm::cbegin(this->Levels), cm::cend(this->Levels),
ParseStd(*defaultStandard)) == cm::cend(this->Levels)) {
const std::string e = cmStrCat("The CMAKE_", this->Language,
"_STANDARD_DEFAULT variable contains an "
"invalid value: \"",
*defaultStandard, "\".");
makefile->IssueMessage(MessageType::INTERNAL_ERROR, e);
return false;
}
cmValue existingStandard =
target->GetLanguageStandard(this->Language, config);
if (!existingStandard) {
existingStandard = defaultStandard;
}
auto existingLevelIter =
std::find(cm::cbegin(this->Levels), cm::cend(this->Levels),
ParseStd(*existingStandard));
if (existingLevelIter == cm::cend(this->Levels)) {
const std::string e =
cmStrCat("The ", this->Language, "_STANDARD property on target \"",
target->GetName(), "\" contained an invalid value: \"",
*existingStandard, "\".");
makefile->IssueMessage(MessageType::FATAL_ERROR, e);
return false;
}
auto needed = this->HighestStandardNeeded(makefile, feature);
return (needed.index == -1) ||
(this->Levels.begin() + needed.index) <= existingLevelIter;
}
StandardNeeded HighestStandardNeeded(cmMakefile* makefile,
std::string const& feature) const
{
std::string prefix = cmStrCat("CMAKE_", this->Language);
StandardNeeded maxLevel = { -1, -1 };
for (size_t i = 0; i < this->Levels.size(); ++i) {
if (cmValue prop = makefile->GetDefinition(
cmStrCat(prefix, this->LevelsAsStrings[i], "_COMPILE_FEATURES"))) {
std::vector<std::string> props = cmExpandedList(*prop);
if (cm::contains(props, feature)) {
maxLevel = { static_cast<int>(i), this->Levels[i] };
}
}
}
return maxLevel;
}
bool IsLaterStandard(int lhs, int rhs) const
{
auto rhsIt =
std::find(cm::cbegin(this->Levels), cm::cend(this->Levels), rhs);
return std::find(rhsIt, cm::cend(this->Levels), lhs) !=
cm::cend(this->Levels);
}
std::string Language;
std::vector<int> Levels;
std::vector<std::string> LevelsAsStrings;
};
std::unordered_map<std::string, StandardLevelComputer>
StandardComputerMapping = {
{ "C",
StandardLevelComputer{
"C", std::vector<int>{ 90, 99, 11, 17, 23 },
std::vector<std::string>{ "90", "99", "11", "17", "23" } } },
{ "CXX",
StandardLevelComputer{
"CXX", std::vector<int>{ 98, 11, 14, 17, 20, 23 },
std::vector<std::string>{ "98", "11", "14", "17", "20", "23" } } },
{ "CUDA",
StandardLevelComputer{
"CUDA", std::vector<int>{ 03, 11, 14, 17, 20, 23 },
std::vector<std::string>{ "03", "11", "14", "17", "20", "23" } } },
{ "OBJC",
StandardLevelComputer{
"OBJC", std::vector<int>{ 90, 99, 11, 17, 23 },
std::vector<std::string>{ "90", "99", "11", "17", "23" } } },
{ "OBJCXX",
StandardLevelComputer{
"OBJCXX", std::vector<int>{ 98, 11, 14, 17, 20, 23 },
std::vector<std::string>{ "98", "11", "14", "17", "20", "23" } } },
{ "HIP",
StandardLevelComputer{
"HIP", std::vector<int>{ 98, 11, 14, 17, 20, 23 },
std::vector<std::string>{ "98", "11", "14", "17", "20", "23" } } }
};
}
std::string cmStandardLevelResolver::GetCompileOptionDef(
cmGeneratorTarget const* target, std::string const& lang,
std::string const& config) const
{
const auto& mapping = StandardComputerMapping.find(lang);
if (mapping == cm::cend(StandardComputerMapping)) {
return std::string{};
}
return mapping->second.GetCompileOptionDef(this->Makefile, target, config);
}
bool cmStandardLevelResolver::AddRequiredTargetFeature(
cmTarget* target, const std::string& feature, std::string* error) const
{
if (cmGeneratorExpression::Find(feature) != std::string::npos) {
target->AppendProperty("COMPILE_FEATURES", feature);
return true;
}
std::string lang;
if (!this->CheckCompileFeaturesAvailable(target->GetName(), feature, lang,
error)) {
return false;
}
target->AppendProperty("COMPILE_FEATURES", feature);
// FIXME: Add a policy to avoid updating the <LANG>_STANDARD target
// property due to COMPILE_FEATURES. The language standard selection
// should be done purely at generate time based on whatever the project
// code put in these properties explicitly. That is mostly true now,
// but for compatibility we need to continue updating the property here.
std::string newRequiredStandard;
bool newRequired = this->GetNewRequiredStandard(
target->GetName(), feature,
target->GetProperty(cmStrCat(lang, "_STANDARD")), newRequiredStandard,
error);
if (!newRequiredStandard.empty()) {
target->SetProperty(cmStrCat(lang, "_STANDARD"), newRequiredStandard);
}
return newRequired;
}
bool cmStandardLevelResolver::CheckCompileFeaturesAvailable(
const std::string& targetName, const std::string& feature, std::string& lang,
std::string* error) const
{
if (!this->CompileFeatureKnown(targetName, feature, lang, error)) {
return false;
}
if (!this->Makefile->GetGlobalGenerator()->GetLanguageEnabled(lang)) {
return true;
}
cmValue features = this->CompileFeaturesAvailable(lang, error);
if (!features) {
return false;
}
std::vector<std::string> availableFeatures = cmExpandedList(features);
if (!cm::contains(availableFeatures, feature)) {
std::ostringstream e;
e << "The compiler feature \"" << feature << "\" is not known to " << lang
<< " compiler\n\""
<< this->Makefile->GetSafeDefinition("CMAKE_" + lang + "_COMPILER_ID")
<< "\"\nversion "
<< this->Makefile->GetSafeDefinition("CMAKE_" + lang +
"_COMPILER_VERSION")
<< ".";
if (error) {
*error = e.str();
} else {
this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
}
return false;
}
return true;
}
bool cmStandardLevelResolver::CompileFeatureKnown(
const std::string& targetName, const std::string& feature, std::string& lang,
std::string* error) const
{
assert(cmGeneratorExpression::Find(feature) == std::string::npos);
bool isCFeature =
std::find_if(cm::cbegin(C_FEATURES) + 1, cm::cend(C_FEATURES),
cmStrCmp(feature)) != cm::cend(C_FEATURES);
if (isCFeature) {
lang = "C";
return true;
}
bool isCxxFeature =
std::find_if(cm::cbegin(CXX_FEATURES) + 1, cm::cend(CXX_FEATURES),
cmStrCmp(feature)) != cm::cend(CXX_FEATURES);
if (isCxxFeature) {
lang = "CXX";
return true;
}
bool isCudaFeature =
std::find_if(cm::cbegin(CUDA_FEATURES) + 1, cm::cend(CUDA_FEATURES),
cmStrCmp(feature)) != cm::cend(CUDA_FEATURES);
if (isCudaFeature) {
lang = "CUDA";
return true;
}
bool isHIPFeature =
std::find_if(cm::cbegin(HIP_FEATURES) + 1, cm::cend(HIP_FEATURES),
cmStrCmp(feature)) != cm::cend(HIP_FEATURES);
if (isHIPFeature) {
lang = "HIP";
return true;
}
std::ostringstream e;
if (error) {
e << "specified";
} else {
e << "Specified";
}
e << " unknown feature \"" << feature
<< "\" for "
"target \""
<< targetName << "\".";
if (error) {
*error = e.str();
} else {
this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
}
return false;
}
cmValue cmStandardLevelResolver::CompileFeaturesAvailable(
const std::string& lang, std::string* error) const
{
if (!this->Makefile->GetGlobalGenerator()->GetLanguageEnabled(lang)) {
std::ostringstream e;
if (error) {
e << "cannot";
} else {
e << "Cannot";
}
e << " use features from non-enabled language " << lang;
if (error) {
*error = e.str();
} else {
this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
}
return nullptr;
}
cmValue featuresKnown =
this->Makefile->GetDefinition("CMAKE_" + lang + "_COMPILE_FEATURES");
if (!cmNonempty(featuresKnown)) {
std::ostringstream e;
if (error) {
e << "no";
} else {
e << "No";
}
e << " known features for " << lang << " compiler\n\""
<< this->Makefile->GetSafeDefinition("CMAKE_" + lang + "_COMPILER_ID")
<< "\"\nversion "
<< this->Makefile->GetSafeDefinition("CMAKE_" + lang +
"_COMPILER_VERSION")
<< ".";
if (error) {
*error = e.str();
} else {
this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
}
return nullptr;
}
return featuresKnown;
}
bool cmStandardLevelResolver::GetNewRequiredStandard(
const std::string& targetName, const std::string& feature,
cmValue currentLangStandardValue, std::string& newRequiredStandard,
std::string* error) const
{
std::string lang;
if (!this->CheckCompileFeaturesAvailable(targetName, feature, lang, error)) {
return false;
}
auto mapping = StandardComputerMapping.find(lang);
if (mapping != cm::cend(StandardComputerMapping)) {
return mapping->second.GetNewRequiredStandard(
this->Makefile, targetName, feature, currentLangStandardValue,
newRequiredStandard, error);
}
return false;
}
bool cmStandardLevelResolver::HaveStandardAvailable(
cmGeneratorTarget const* target, std::string const& lang,
std::string const& config, const std::string& feature) const
{
auto mapping = StandardComputerMapping.find(lang);
if (mapping != cm::cend(StandardComputerMapping)) {
return mapping->second.HaveStandardAvailable(this->Makefile, target,
config, feature);
}
return false;
}
bool cmStandardLevelResolver::IsLaterStandard(std::string const& lang,
std::string const& lhs,
std::string const& rhs) const
{
auto mapping = StandardComputerMapping.find(lang);
if (mapping != cm::cend(StandardComputerMapping)) {
return mapping->second.IsLaterStandard(std::stoi(lhs), std::stoi(rhs));
}
return false;
}