kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge topic 'refactor-cmPolicies' 

013ada80 cmPolicies: Implement PolicyMap in terms of bitset.
be6664c2 cmPolicies: Implement abstraction for PolicyMap.
de211686 Port to static cmPolicies API.
13981f20 cmPolicies: Make all API static.
23e2bcc8 cmPolicies: Remove unused DefinePolicy method.
5641ba4f cmPolicies: Remove unused cmPolicy class.
3de54497 cmPolicies: Loop over all policies using enum constants.
387aff20 cmPolicies: Trivialize GetPolicyStatus method.
dbf680d6 cmPolicies: Use more-direct ID access.
8c204133 cmPolicies: Implement in terms of public API.
e3a8c029 cmPolicies: Make private method file-static.
cb765af0 cmPolicies: Implement short description access with XMacros.
5df267fa cmPolicies: Implement version check with XMacro.
2235cfeb cmPolicies: Implement id to version with XMacro.
05d84388 cmPolicies: Implement id to string conversion with XMacro.
6eaade8a cmPolicies: Introduce XMacro table for policy data.
...
This commit is contained in:
Brad King 2015-05-05 09:35:30 -04:00 committed by CMake Topic Stage
parent b492a17611 013ada80ea
commit 2c5a1bff23
28 changed files with 538 additions and 806 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Source/cmAddCustomCommandCommand.cxx
View File

@ -380,8 +380,7 @@ bool cmAddCustomCommandCommand
switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0050))
{
case cmPolicies::WARN:
e << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0050)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0050) << "\n";
break;
case cmPolicies::OLD:
issueMessage = false;

3
Source/cmAddCustomTargetCommand.cxx
View File

@ -194,8 +194,7 @@ bool cmAddCustomTargetCommand
switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0037))
{
case cmPolicies::WARN:
e << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0037)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0037) << "\n";
issueMessage = true;
case cmPolicies::OLD:
break;

3
Source/cmAddExecutableCommand.cxx
View File

@ -84,8 +84,7 @@ bool cmAddExecutableCommand
switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0037))
{
case cmPolicies::WARN:
e << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0037)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0037) << "\n";
issueMessage = true;
case cmPolicies::OLD:
break;

3
Source/cmAddLibraryCommand.cxx
View File

@ -222,8 +222,7 @@ bool cmAddLibraryCommand
case cmPolicies::WARN:
if(type != cmTarget::INTERFACE_LIBRARY)
{
e << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0037)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0037) << "\n";
issueMessage = true;
}
case cmPolicies::OLD:

6
Source/cmBreakCommand.cxx
View File

@ -23,8 +23,7 @@ bool cmBreakCommand::InitialPass(std::vector<std::string> const &args,
switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0055))
{
case cmPolicies::WARN:
e << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0055)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0055) << "\n";
break;
case cmPolicies::OLD:
issueMessage = false;
@ -58,8 +57,7 @@ bool cmBreakCommand::InitialPass(std::vector<std::string> const &args,
switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0055))
{
case cmPolicies::WARN:
e << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0055)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0055) << "\n";
break;
case cmPolicies::OLD:
issueMessage = false;

4
Source/cmCMakePolicyCommand.cxx
View File

@ -111,7 +111,7 @@ bool cmCMakePolicyCommand::HandleGetMode(std::vector<std::string> const& args)
// Lookup the policy number.
cmPolicies::PolicyID pid;
if(!this->Makefile->GetPolicies()->GetPolicyID(id.c_str(), pid))
if(!cmPolicies::GetPolicyID(id.c_str(), pid))
{
std::ostringstream e;
e << "GET given policy \"" << id << "\" which is not known to this "
@ -141,7 +141,7 @@ bool cmCMakePolicyCommand::HandleGetMode(std::vector<std::string> const& args)
// The policy is required to be set before anything needs it.
{
std::ostringstream e;
e << this->Makefile->GetPolicies()->GetRequiredPolicyError(pid)
e << cmPolicies::GetRequiredPolicyError(pid)
<< "\n"
<< "The call to cmake_policy(GET " << id << " ...) at which this "
<< "error appears requests the policy, and this version of CMake "

2
Source/cmCommand.h
View File

@ -180,7 +180,7 @@ public:
{
case cmPolicies::WARN:
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
this->Makefile->GetPolicies()->GetPolicyWarning(pol));
cmPolicies::GetPolicyWarning(pol));
case cmPolicies::OLD:
return false;
case cmPolicies::REQUIRED_IF_USED:

12
Source/cmComputeLinkInformation.cxx
View File

@ -556,8 +556,7 @@ bool cmComputeLinkInformation::Compute()
if (!this->CMP0060WarnItems.empty())
{
std::ostringstream w;
w << (this->Makefile->GetCMakeInstance()->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0060)) << "\n"
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0060) << "\n"
"Some library files are in directories implicitly searched by "
"the linker when invoked for " << this->LinkLanguage << ":\n"
" " << cmJoin(this->CMP0060WarnItems, "\n ") << "\n"
@ -1534,8 +1533,7 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
{
this->CMakeInstance->GetState()->SetGlobalProperty(wid, "1");
std::ostringstream w;
w << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0008)) << "\n"
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0008) << "\n"
<< "Target \"" << this->Target->GetName() << "\" links to item\n"
<< " " << item << "\n"
<< "which is a full-path but not a valid library file name.";
@ -1553,8 +1551,7 @@ void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
case cmPolicies::REQUIRED_ALWAYS:
{
std::ostringstream e;
e << (this->Makefile->GetPolicies()->
GetRequiredPolicyError(cmPolicies::CMP0008)) << "\n"
e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0008) << "\n"
<< "Target \"" << this->Target->GetName() << "\" links to item\n"
<< " " << item << "\n"
<< "which is a full-path but not a valid library file name.";
@ -1600,8 +1597,7 @@ bool cmComputeLinkInformation::FinishLinkerSearchDirectories()
case cmPolicies::REQUIRED_ALWAYS:
{
std::ostringstream e;
e << (this->Makefile->GetPolicies()->
GetRequiredPolicyError(cmPolicies::CMP0003)) << "\n";
e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0003) << "\n";
this->PrintLinkPolicyDiagnosis(e);
this->CMakeInstance->IssueMessage(cmake::FATAL_ERROR, e.str(),
this->Target->GetBacktrace());

4
Source/cmComputeTargetDepends.cxx
View File

@ -359,15 +359,13 @@ void cmComputeTargetDepends::AddTargetDepend(
if(!dependee && !linking &&
(depender->GetType() != cmTarget::GLOBAL_TARGET))
{
cmMakefile *makefile = depender->GetMakefile();
cmake::MessageType messageType = cmake::AUTHOR_WARNING;
bool issueMessage = false;
std::ostringstream e;
switch(depender->GetPolicyStatusCMP0046())
{
case cmPolicies::WARN:
e << (makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0046)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0046) << "\n";
issueMessage = true;
case cmPolicies::OLD:
break;

18
Source/cmConditionEvaluator.cxx
View File

@ -118,8 +118,7 @@ const char* cmConditionEvaluator::GetDefinitionIfUnquoted(
if(!hasBeenReported)
{
std::ostringstream e;
e << (this->Makefile.GetPolicies()->GetPolicyWarning(
cmPolicies::CMP0054)) << "\n";
e << (cmPolicies::GetPolicyWarning(cmPolicies::CMP0054)) << "\n";
e << "Quoted variables like \"" << argument.GetValue() <<
"\" will no longer be dereferenced "
"when the policy is set to NEW. "
@ -168,8 +167,7 @@ bool cmConditionEvaluator::IsKeyword(std::string const& keyword,
if(!hasBeenReported)
{
std::ostringstream e;
e << (this->Makefile.GetPolicies()->GetPolicyWarning(
cmPolicies::CMP0054)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0054) << "\n";
e << "Quoted keywords like \"" << argument.GetValue() <<
"\" will no longer be interpreted as keywords "
"when the policy is set to NEW. "
@ -280,10 +278,9 @@ bool cmConditionEvaluator::GetBooleanValueWithAutoDereference(
{
case cmPolicies::WARN:
{
cmPolicies* policies = this->Makefile.GetPolicies();
errorString = "An argument named \"" + newArg.GetValue()
+ "\" appears in a conditional statement. "
+ policies->GetPolicyWarning(cmPolicies::CMP0012);
+ cmPolicies::GetPolicyWarning(cmPolicies::CMP0012);
status = cmake::AUTHOR_WARNING;
}
case cmPolicies::OLD:
@ -291,10 +288,9 @@ bool cmConditionEvaluator::GetBooleanValueWithAutoDereference(
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
{
cmPolicies* policies = this->Makefile.GetPolicies();
errorString = "An argument named \"" + newArg.GetValue()
+ "\" appears in a conditional statement. "
+ policies->GetRequiredPolicyError(cmPolicies::CMP0012);
+ cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0012);
status = cmake::FATAL_ERROR;
}
case cmPolicies::NEW:
@ -493,8 +489,7 @@ bool cmConditionEvaluator::HandleLevel1(cmArgumentList &newArgs,
{
cmPolicies::PolicyID pid;
this->HandlePredicate(
this->Makefile.GetPolicies()->GetPolicyID(
argP1->c_str(), pid),
cmPolicies::GetPolicyID(argP1->c_str(), pid),
reducible, arg, newArgs, argP1, argP2);
}
// does a target exist
@ -702,8 +697,7 @@ bool cmConditionEvaluator::HandleLevel2(cmArgumentList &newArgs,
else if(this->Policy57Status == cmPolicies::WARN)
{
std::ostringstream e;
e << (this->Makefile.GetPolicies()->GetPolicyWarning(
cmPolicies::CMP0057)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0057) << "\n";
e << "IN_LIST will be interpreted as an operator "
"when the policy is set to NEW. "
"Since the policy is not set the OLD behavior will be used.";

6
Source/cmCoreTryCompile.cxx
View File

@ -334,8 +334,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv)
"CMAKE_POLICY_WARNING_CMP0056"))
{
std::ostringstream w;
w << (this->Makefile->GetCMakeInstance()->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0056)) << "\n"
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0056) << "\n"
"For compatibility with older versions of CMake, try_compile "
"is not honoring caller link flags (e.g. CMAKE_EXE_LINKER_FLAGS) "
"in the test project."
@ -349,8 +348,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv)
case cmPolicies::REQUIRED_ALWAYS:
this->Makefile->IssueMessage(
cmake::FATAL_ERROR,
this->Makefile->GetCMakeInstance()->GetPolicies()
->GetRequiredPolicyError(cmPolicies::CMP0056)
cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0056)
);
case cmPolicies::NEW:
// NEW behavior is to pass linker flags.

6
Source/cmExportFileGenerator.cxx
View File

@ -257,8 +257,7 @@ static bool checkInterfaceDirs(const std::string &prepro,
{
case cmPolicies::WARN:
messageType = cmake::WARNING;
e << target->GetMakefile()->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0041) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0041) << "\n";
break;
case cmPolicies::OLD:
continue;
@ -306,8 +305,7 @@ static bool checkInterfaceDirs(const std::string &prepro,
case cmPolicies::WARN:
{
std::ostringstream s;
s << target->GetMakefile()->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0052) << "\n";
s << cmPolicies::GetPolicyWarning(cmPolicies::CMP0052) << "\n";
s << "Directory:\n \"" << *li << "\"\nin "
"INTERFACE_INCLUDE_DIRECTORIES of target \""
<< target->GetName() << "\" is a subdirectory of the install "

6
Source/cmFileCommand.cxx
View File

@ -1056,16 +1056,14 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
if(g.GetFollowedSymlinkCount() != 0)
{
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
this->Makefile->GetPolicies()->
GetPolicyWarning(cmPolicies::CMP0009));
cmPolicies::GetPolicyWarning(cmPolicies::CMP0009));
}
break;
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
this->SetError("policy CMP0009 error");
this->Makefile->IssueMessage(cmake::FATAL_ERROR,
this->Makefile->GetPolicies()->
GetRequiredPolicyError(cmPolicies::CMP0009));
cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0009));
return false;
}
}

6
Source/cmGeneratorExpressionNode.cxx
View File

@ -395,8 +395,7 @@ struct CompilerIdNode : public cmGeneratorExpressionNode
case cmPolicies::WARN:
{
std::ostringstream e;
e << context->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0044);
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0044);
context->Makefile->GetCMakeInstance()
->IssueMessage(cmake::AUTHOR_WARNING,
e.str(), context->Backtrace);
@ -1494,8 +1493,7 @@ static const struct TargetPolicyNode : public cmGeneratorExpressionNode
{
case cmPolicies::WARN:
mf->IssueMessage(cmake::AUTHOR_WARNING,
mf->GetPolicies()->
GetPolicyWarning(policyForString(policy)));
cmPolicies::GetPolicyWarning(policyForString(policy)));
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
case cmPolicies::OLD:

3
Source/cmGetTargetPropertyCommand.cxx
View File

@ -56,8 +56,7 @@ bool cmGetTargetPropertyCommand
{
case cmPolicies::WARN:
issueMessage = true;
e << this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0045) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0045) << "\n";
case cmPolicies::OLD:
break;
case cmPolicies::REQUIRED_IF_USED:

14
Source/cmGlobalGenerator.cxx
View File

@ -826,7 +826,6 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
if(strcmp(compilerId, "AppleClang") == 0)
{
cmPolicies* policies = this->CMakeInstance->GetPolicies();
switch(mf->GetPolicyStatus(cmPolicies::CMP0025))
{
case cmPolicies::WARN:
@ -834,7 +833,7 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
mf->PolicyOptionalWarningEnabled("CMAKE_POLICY_WARNING_CMP0025"))
{
std::ostringstream w;
w << policies->GetPolicyWarning(cmPolicies::CMP0025) << "\n"
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0025) << "\n"
"Converting " << lang <<
" compiler id \"AppleClang\" to \"Clang\" for compatibility."
;
@ -848,7 +847,7 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
case cmPolicies::REQUIRED_ALWAYS:
mf->IssueMessage(
cmake::FATAL_ERROR,
policies->GetRequiredPolicyError(cmPolicies::CMP0025)
cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0025)
);
case cmPolicies::NEW:
// NEW behavior is to keep AppleClang.
@ -858,7 +857,6 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
if(strcmp(compilerId, "QCC") == 0)
{
cmPolicies* policies = this->CMakeInstance->GetPolicies();
switch(mf->GetPolicyStatus(cmPolicies::CMP0047))
{
case cmPolicies::WARN:
@ -866,7 +864,7 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
mf->PolicyOptionalWarningEnabled("CMAKE_POLICY_WARNING_CMP0047"))
{
std::ostringstream w;
w << policies->GetPolicyWarning(cmPolicies::CMP0047) << "\n"
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0047) << "\n"
"Converting " << lang <<
" compiler id \"QCC\" to \"GNU\" for compatibility."
;
@ -888,7 +886,7 @@ void cmGlobalGenerator::CheckCompilerIdCompatibility(cmMakefile* mf,
case cmPolicies::REQUIRED_ALWAYS:
mf->IssueMessage(
cmake::FATAL_ERROR,
policies->GetRequiredPolicyError(cmPolicies::CMP0047)
cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0047)
);
case cmPolicies::NEW:
// NEW behavior is to keep QCC.
@ -1327,9 +1325,7 @@ void cmGlobalGenerator::Generate()
if(!this->CMP0042WarnTargets.empty())
{
std::ostringstream w;
w <<
(this->GetCMakeInstance()->GetPolicies()->
GetPolicyWarning(cmPolicies::CMP0042)) << "\n";
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0042) << "\n";
w << "MACOSX_RPATH is not specified for"
" the following targets:\n";
for(std::set<std::string>::iterator

4
Source/cmGlobalNinjaGenerator.cxx
View File

@ -1103,9 +1103,7 @@ void cmGlobalNinjaGenerator::WriteUnknownExplicitDependencies(std::ostream& os)
if (!warnExplicitDepends.empty())
{
std::ostringstream w;
w <<
(this->GetCMakeInstance()->GetPolicies()->
GetPolicyWarning(cmPolicies::CMP0058)) << "\n"
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0058) << "\n"
"This project specifies custom command DEPENDS on files "
"in the build tree that are not specified as the OUTPUT or "
"BYPRODUCTS of any add_custom_command or add_custom_target:\n"

3
Source/cmIncludeCommand.cxx
View File

@ -103,8 +103,7 @@ bool cmIncludeCommand
switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0024))
{
case cmPolicies::WARN:
e << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0024)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0024) << "\n";
modal = "should";
case cmPolicies::OLD:
break;

5
Source/cmInstallCommand.cxx
View File

@ -1402,7 +1402,7 @@ bool cmInstallCommand::CheckCMP0006(bool& failure)
{
this->Makefile->IssueMessage(
cmake::AUTHOR_WARNING,
this->Makefile->GetPolicies()->GetPolicyWarning(cmPolicies::CMP0006)
cmPolicies::GetPolicyWarning(cmPolicies::CMP0006)
);
}
case cmPolicies::OLD:
@ -1416,8 +1416,7 @@ bool cmInstallCommand::CheckCMP0006(bool& failure)
failure = true;
this->Makefile->IssueMessage(
cmake::FATAL_ERROR,
this->Makefile->GetPolicies()
->GetRequiredPolicyError(cmPolicies::CMP0006)
cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0006)
);
break;
}

5
Source/cmLinkDirectoriesCommand.cxx
View File

@ -40,18 +40,17 @@ void cmLinkDirectoriesCommand::AddLinkDir(std::string const& dir)
e << "This command specifies the relative path\n"
<< " " << unixPath << "\n"
<< "as a link directory.\n";
cmPolicies* policies = this->Makefile->GetPolicies();
switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0015))
{
case cmPolicies::WARN:
e << policies->GetPolicyWarning(cmPolicies::CMP0015);
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0015);
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, e.str());
case cmPolicies::OLD:
// OLD behavior does not convert
break;
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
e << policies->GetRequiredPolicyError(cmPolicies::CMP0015);
e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0015);
this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
case cmPolicies::NEW:
// NEW behavior converts

6
Source/cmListCommand.cxx
View File

@ -121,8 +121,7 @@ bool cmListCommand::GetList(std::vector<std::string>& list,
// empty values
list.clear();
cmSystemTools::ExpandListArgument(listString, list);
std::string warn = this->Makefile->GetPolicies()->
GetPolicyWarning(cmPolicies::CMP0007);
std::string warn = cmPolicies::GetPolicyWarning(cmPolicies::CMP0007);
warn += " List has value = [";
warn += listString;
warn += "].";
@ -143,8 +142,7 @@ bool cmListCommand::GetList(std::vector<std::string>& list,
case cmPolicies::REQUIRED_ALWAYS:
this->Makefile->IssueMessage(
cmake::FATAL_ERROR,
this->Makefile->GetPolicies()
->GetRequiredPolicyError(cmPolicies::CMP0007)
cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0007)
);
return false;
}

7
Source/cmLocalGenerator.cxx
View File

@ -209,7 +209,7 @@ void cmLocalGenerator::ReadInputFile()
<< "to work accidentally and is being allowed for "
<< "compatibility."
<< "\n"
<< mf->GetPolicies()->GetPolicyWarning(cmPolicies::CMP0014);
<< cmPolicies::GetPolicyWarning(cmPolicies::CMP0014);
mf->IssueMessage(cmake::AUTHOR_WARNING, e.str());
case cmPolicies::OLD:
// OLD behavior does not warn.
@ -217,7 +217,7 @@ void cmLocalGenerator::ReadInputFile()
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
e << "\n"
<< mf->GetPolicies()->GetRequiredPolicyError(cmPolicies::CMP0014);
<< cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0014);
case cmPolicies::NEW:
// NEW behavior prints the error.
mf->IssueMessage(cmake::FATAL_ERROR, e.str());
@ -2458,8 +2458,7 @@ bool cmLocalGenerator::GetShouldUseOldFlags(bool shared,
"shared libraries and will use the " << flagsVar << " variable "
"instead. This may cause errors if the original content of "
<< flagsVar << " was removed.\n"
<< this->Makefile->GetPolicies()->GetPolicyWarning(
cmPolicies::CMP0018);
<< cmPolicies::GetPolicyWarning(cmPolicies::CMP0018);
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, e.str());
// fall through to OLD behaviour

69
Source/cmMakefile.cxx
View File

@ -560,7 +560,7 @@ cmMakefile::IncludeScope::~IncludeScope()
// one we pushed above. If the entry is empty, then the included
// script did not set any policies that might affect the includer so
// we do not need to enforce the policy.
if(this->CheckCMP0011 && this->Makefile->PolicyStack.back().empty())
if(this->CheckCMP0011 && this->Makefile->PolicyStack.back().IsEmpty())
{
this->CheckCMP0011 = false;
}
@ -582,14 +582,13 @@ void cmMakefile::IncludeScope::EnforceCMP0011()
{
// We check the setting of this policy again because the included
// script might actually set this policy for its includer.
cmPolicies* policies = this->Makefile->GetPolicies();
switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0011))
{
case cmPolicies::WARN:
// Warn because the user did not set this policy.
{
std::ostringstream w;
w << policies->GetPolicyWarning(cmPolicies::CMP0011) << "\n"
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0011) << "\n"
<< "The included script\n " << this->File << "\n"
<< "affects policy settings. "
<< "CMake is implying the NO_POLICY_SCOPE option for compatibility, "
@ -601,7 +600,7 @@ void cmMakefile::IncludeScope::EnforceCMP0011()
case cmPolicies::REQUIRED_ALWAYS:
{
std::ostringstream e;
e << policies->GetRequiredPolicyError(cmPolicies::CMP0011) << "\n"
e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0011) << "\n"
<< "The included script\n " << this->File << "\n"
<< "affects policy settings, so it requires this policy to be set.";
this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
@ -870,8 +869,7 @@ cmMakefile::AddCustomCommandToTarget(const std::string& target,
switch(this->GetPolicyStatus(cmPolicies::CMP0040))
{
case cmPolicies::WARN:
e << (this->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0040)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0040) << "\n";
issueMessage = true;
case cmPolicies::OLD:
break;
@ -1428,7 +1426,7 @@ bool cmMakefile::ParseDefineFlag(std::string const& def, bool remove)
case cmPolicies::WARN:
this->IssueMessage(
cmake::AUTHOR_WARNING,
this->GetPolicies()->GetPolicyWarning(cmPolicies::CMP0005)
cmPolicies::GetPolicyWarning(cmPolicies::CMP0005)
);
case cmPolicies::OLD:
// OLD behavior is to not escape the value. We should not
@ -1438,7 +1436,7 @@ bool cmMakefile::ParseDefineFlag(std::string const& def, bool remove)
case cmPolicies::REQUIRED_ALWAYS:
this->IssueMessage(
cmake::FATAL_ERROR,
this->GetPolicies()->GetRequiredPolicyError(cmPolicies::CMP0005)
cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0005)
);
return false;
case cmPolicies::NEW:
@ -2323,7 +2321,7 @@ void cmMakefile::ExpandVariablesCMP0019()
if(!w.str().empty())
{
std::ostringstream m;
m << this->GetPolicies()->GetPolicyWarning(cmPolicies::CMP0019)
m << cmPolicies::GetPolicyWarning(cmPolicies::CMP0019)
<< "\n"
<< "The following variable evaluations were encountered:\n"
<< w.str();
@ -2581,7 +2579,7 @@ const char *cmMakefile::ExpandVariablesInString(std::string& source,
else if(compareResults && (newResult != source || newError != mtype))
{
std::string msg =
this->GetPolicies()->GetPolicyWarning(cmPolicies::CMP0053);
cmPolicies::GetPolicyWarning(cmPolicies::CMP0053);
msg += "\n";
std::string msg_input = original;
@ -2733,9 +2731,7 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringOld(
switch(this->GetPolicyStatus(cmPolicies::CMP0010))
{
case cmPolicies::WARN:
error << "\n"
<< (this->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0010));
error << "\n" << cmPolicies::GetPolicyWarning(cmPolicies::CMP0010);
case cmPolicies::OLD:
// OLD behavior is to just warn and continue.
mtype = cmake::AUTHOR_WARNING;
@ -2743,8 +2739,7 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringOld(
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
error << "\n"
<< (this->GetPolicies()
->GetRequiredPolicyError(cmPolicies::CMP0010));
<< cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0010);
case cmPolicies::NEW:
// NEW behavior is to report the error.
break;
@ -3804,7 +3799,7 @@ std::string cmMakefile::GetModulesFile(const char* filename) const
<< moduleInCMakeModulePath
<< " (found via CMAKE_MODULE_PATH) which shadows "
<< moduleInCMakeRoot << ". This may cause errors later on .\n"
<< this->GetPolicies()->GetPolicyWarning(cmPolicies::CMP0017);
<< cmPolicies::GetPolicyWarning(cmPolicies::CMP0017);
this->IssueMessage(cmake::AUTHOR_WARNING, e.str());
// break; // fall through to OLD behaviour
@ -4172,7 +4167,7 @@ const char *cmMakefile::GetProperty(const std::string& prop,
switch(this->GetPolicyStatus(cmPolicies::CMP0059))
{
case cmPolicies::WARN:
this->IssueMessage(cmake::AUTHOR_WARNING, this->GetPolicies()->
this->IssueMessage(cmake::AUTHOR_WARNING, cmPolicies::
GetPolicyWarning(cmPolicies::CMP0059));
case cmPolicies::OLD:
output += this->DefineFlagsOrig;
@ -4538,14 +4533,14 @@ bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg,
switch (this->GetPolicyStatus(cmPolicies::CMP0002))
{
case cmPolicies::WARN:
this->IssueMessage(cmake::AUTHOR_WARNING, this->GetPolicies()->
this->IssueMessage(cmake::AUTHOR_WARNING, cmPolicies::
GetPolicyWarning(cmPolicies::CMP0002));
case cmPolicies::OLD:
return true;
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
this->IssueMessage(cmake::FATAL_ERROR,
this->GetPolicies()->GetRequiredPolicyError(cmPolicies::CMP0002)
cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0002)
);
return true;
case cmPolicies::NEW:
@ -4616,7 +4611,7 @@ bool cmMakefile::EnforceUniqueDir(const std::string& srcPath,
{
case cmPolicies::WARN:
// Print the warning.
e << this->GetPolicies()->GetPolicyWarning(cmPolicies::CMP0013)
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0013)
<< "\n"
<< "The binary directory\n"
<< " " << binPath << "\n"
@ -4633,7 +4628,7 @@ bool cmMakefile::EnforceUniqueDir(const std::string& srcPath,
return true;
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
e << this->GetPolicies()->GetRequiredPolicyError(cmPolicies::CMP0013)
e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0013)
<< "\n";
case cmPolicies::NEW:
// NEW behavior prints the error.
@ -4736,7 +4731,7 @@ cmMakefile::GetPolicyStatus(cmPolicies::PolicyID id) const
{
return cur;
}
cmPolicies::PolicyStatus def = this->GetPolicies()->GetPolicyStatus(id);
cmPolicies::PolicyStatus def = cmPolicies::GetPolicyStatus(id);
if(def == cmPolicies::REQUIRED_ALWAYS ||
def == cmPolicies::REQUIRED_IF_USED)
{
@ -4756,10 +4751,9 @@ cmMakefile::GetPolicyStatusInternal(cmPolicies::PolicyID id) const
for(PolicyStackType::const_reverse_iterator psi = this->PolicyStack.rbegin();
psi != this->PolicyStack.rend(); ++psi)
{
PolicyStackEntry::const_iterator pse = psi->find(id);
if(pse != psi->end())
if(psi->IsDefined(id))
{
return pse->second;
return psi->Get(id);
}
}
@ -4771,7 +4765,7 @@ cmMakefile::GetPolicyStatusInternal(cmPolicies::PolicyID id) const
}
// The policy is not set. Use the default for this CMake version.
return this->GetPolicies()->GetPolicyStatus(id);
return cmPolicies::GetPolicyStatus(id);
}
//----------------------------------------------------------------------------
@ -4794,7 +4788,7 @@ bool cmMakefile::SetPolicy(const char *id,
cmPolicies::PolicyStatus status)
{
cmPolicies::PolicyID pid;
if (!this->GetPolicies()->GetPolicyID(id, /* out */ pid))
if (!cmPolicies::GetPolicyID(id, /* out */ pid))
{
std::ostringstream e;
e << "Policy \"" << id << "\" is not known to this version of CMake.";
@ -4810,11 +4804,11 @@ bool cmMakefile::SetPolicy(cmPolicies::PolicyID id,
{
// A REQUIRED_ALWAYS policy may be set only to NEW.
if(status != cmPolicies::NEW &&
this->GetPolicies()->GetPolicyStatus(id) ==
cmPolicies::GetPolicyStatus(id) ==
cmPolicies::REQUIRED_ALWAYS)
{
std::string msg =
this->GetPolicies()->GetRequiredAlwaysPolicyError(id);
cmPolicies::GetRequiredAlwaysPolicyError(id);
this->IssueMessage(cmake::FATAL_ERROR, msg);
return false;
}
@ -4824,7 +4818,7 @@ bool cmMakefile::SetPolicy(cmPolicies::PolicyID id,
for(PolicyStackType::reverse_iterator psi = this->PolicyStack.rbegin();
previous_was_weak && psi != this->PolicyStack.rend(); ++psi)
{
(*psi)[id] = status;
psi->Set(id, status);
previous_was_weak = psi->Weak;
}
@ -4916,18 +4910,7 @@ void cmMakefile::PopPolicyBarrier(bool reportError)
//----------------------------------------------------------------------------
bool cmMakefile::SetPolicyVersion(const char *version)
{
return this->GetCMakeInstance()->GetPolicies()->
ApplyPolicyVersion(this,version);
}
//----------------------------------------------------------------------------
cmPolicies *cmMakefile::GetPolicies() const
{
if (!this->GetCMakeInstance())
{
return 0;
}
return this->GetCMakeInstance()->GetPolicies();
return cmPolicies::ApplyPolicyVersion(this,version);
}
//----------------------------------------------------------------------------
@ -4955,7 +4938,7 @@ void cmMakefile::RecordPolicies(cmPolicies::PolicyMap& pm)
for(PolicyID pid = cmPolicies::CMP0000;
pid != cmPolicies::CMPCOUNT; pid = PolicyID(pid+1))
{
pm[pid] = this->GetPolicyStatus(pid);
pm.Set(pid, this->GetPolicyStatus(pid));
}
}

716
Source/cmPolicies.cxx
View File

@ -1,7 +1,6 @@
#include "cmPolicies.h"
#include "cmake.h"
#include "cmMakefile.h"
#include "cmSourceFile.h"
#include "cmVersion.h"
#include "cmVersionMacros.h"
#include "cmAlgorithms.h"
@ -10,421 +9,171 @@
#include <queue>
#include <assert.h>
const char* cmPolicies::PolicyStatusNames[] = {
"OLD", "WARN", "NEW", "REQUIRED_IF_USED", "REQUIRED_ALWAYS"
};
class cmPolicy
static bool stringToId(const char* input, cmPolicies::PolicyID& pid)
{
public:
cmPolicy(cmPolicies::PolicyID iD,
const char *idString,
const char *shortDescription,
unsigned int majorVersionIntroduced,
unsigned int minorVersionIntroduced,
unsigned int patchVersionIntroduced,
cmPolicies::PolicyStatus status)
assert(input);
if (strlen(input) != 7)
{
if (!idString || !shortDescription)
{
cmSystemTools::Error("Attempt to define a policy without "
"all parameters being specified!");
return;
return false;
}
this->ID = iD;
this->IDString = idString;
this->ShortDescription = shortDescription;
this->MajorVersionIntroduced = majorVersionIntroduced;
this->MinorVersionIntroduced = minorVersionIntroduced;
this->PatchVersionIntroduced = patchVersionIntroduced;
this->Status = status;
if (!cmHasLiteralPrefix(input, "CMP"))
{
return false;
}
if (cmHasLiteralSuffix(input, "0000"))
{
pid = cmPolicies::CMP0000;
return true;
}
for (int i = 3; i < 7; ++i)
{
if (!isdigit(*(input + i)))
{
return false;
}
}
long id;
if (!cmSystemTools::StringToLong(input + 3, &id))
{
return false;
}
if (id >= cmPolicies::CMPCOUNT)
{
return false;
}
pid = cmPolicies::PolicyID(id);
return true;
}
std::string GetVersionString()
#define CM_SELECT_ID_VERSION(F, A1, A2, A3, A4, A5, A6) F(A1, A3, A4, A5)
#define CM_FOR_EACH_POLICY_ID_VERSION(POLICY) \
CM_FOR_EACH_POLICY_TABLE(POLICY, CM_SELECT_ID_VERSION)
#define CM_SELECT_ID_DOC(F, A1, A2, A3, A4, A5, A6) F(A1, A2)
#define CM_FOR_EACH_POLICY_ID_DOC(POLICY) \
CM_FOR_EACH_POLICY_TABLE(POLICY, CM_SELECT_ID_DOC)
static const char* idToString(cmPolicies::PolicyID id)
{
std::ostringstream v;
v << this->MajorVersionIntroduced << "." << this->MinorVersionIntroduced;
if(this->PatchVersionIntroduced > 0)
switch(id)
{
v << "." << this->PatchVersionIntroduced;
#define POLICY_CASE(ID) \
case cmPolicies::ID: \
return #ID;
CM_FOR_EACH_POLICY_ID(POLICY_CASE)
#undef POLICY_CASE
case cmPolicies::CMPCOUNT:
return 0;
}
return v.str();
return 0;
}
bool IsPolicyNewerThan(unsigned int majorV,
static const char* idToVersion(cmPolicies::PolicyID id)
{
switch(id)
{
#define POLICY_CASE(ID, V_MAJOR, V_MINOR, V_PATCH) \
case cmPolicies::ID: \
return #V_MAJOR "." #V_MINOR "." #V_PATCH;
CM_FOR_EACH_POLICY_ID_VERSION(POLICY_CASE)
#undef POLICY_CASE
case cmPolicies::CMPCOUNT:
return 0;
}
return 0;
}
static bool isPolicyNewerThan(cmPolicies::PolicyID id,
unsigned int majorV,
unsigned int minorV,
unsigned int patchV)
{
if (majorV < this->MajorVersionIntroduced)
{
return true;
}
if (majorV > this->MajorVersionIntroduced)
switch(id)
{
#define POLICY_CASE(ID, V_MAJOR, V_MINOR, V_PATCH) \
case cmPolicies::ID: \
return (majorV < V_MAJOR || \
(majorV == V_MAJOR && \
minorV + 1 < V_MINOR + 1) || \
(majorV == V_MAJOR && \
minorV == V_MINOR && \
patchV + 1 < V_PATCH + 1));
CM_FOR_EACH_POLICY_ID_VERSION(POLICY_CASE)
#undef POLICY_CASE
case cmPolicies::CMPCOUNT:
return false;
}
if (minorV < this->MinorVersionIntroduced)
{
return true;
}
if (minorV > this->MinorVersionIntroduced)
{
return false;
}
return (patchV < this->PatchVersionIntroduced);
const char* idToShortDescription(cmPolicies::PolicyID id)
{
switch(id)
{
#define POLICY_CASE(ID, SHORT_DESCRIPTION) \
case cmPolicies::ID: \
return SHORT_DESCRIPTION;
CM_FOR_EACH_POLICY_ID_DOC(POLICY_CASE)
#undef POLICY_CASE
case cmPolicies::CMPCOUNT:
return 0;
}
return 0;
}
cmPolicies::PolicyID ID;
std::string IDString;
std::string ShortDescription;
unsigned int MajorVersionIntroduced;
unsigned int MinorVersionIntroduced;
unsigned int PatchVersionIntroduced;
cmPolicies::PolicyStatus Status;
};
cmPolicies::cmPolicies()
//----------------------------------------------------------------------------
static void DiagnoseAncientPolicies(
std::vector<cmPolicies::PolicyID> const& ancient,
unsigned int majorVer,
unsigned int minorVer,
unsigned int patchVer,
cmMakefile* mf)
{
// define all the policies
this->DefinePolicy(
CMP0000, "CMP0000",
"A minimum required CMake version must be specified.",
2,6,0, cmPolicies::WARN
);
this->DefinePolicy(
CMP0001, "CMP0001",
"CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.",
2,6,0, cmPolicies::WARN
);
this->DefinePolicy(
CMP0002, "CMP0002",
"Logical target names must be globally unique.",
2,6,0, cmPolicies::WARN
);
this->DefinePolicy(
CMP0003, "CMP0003",
"Libraries linked via full path no longer produce linker search paths.",
2,6,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0004, "CMP0004",
"Libraries linked may not have leading or trailing whitespace.",
2,6,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0005, "CMP0005",
"Preprocessor definition values are now escaped automatically.",
2,6,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0006, "CMP0006",
"Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.",
2,6,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0007, "CMP0007",
"list command no longer ignores empty elements.",
2,6,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0008, "CMP0008",
"Libraries linked by full-path must have a valid library file name.",
2,6,1, cmPolicies::WARN);
this->DefinePolicy(
CMP0009, "CMP0009",
"FILE GLOB_RECURSE calls should not follow symlinks by default.",
2,6,2, cmPolicies::WARN);
this->DefinePolicy(
CMP0010, "CMP0010",
"Bad variable reference syntax is an error.",
2,6,3, cmPolicies::WARN);
this->DefinePolicy(
CMP0011, "CMP0011",
"Included scripts do automatic cmake_policy PUSH and POP.",
2,6,3, cmPolicies::WARN);
this->DefinePolicy(
CMP0012, "CMP0012",
"if() recognizes numbers and boolean constants.",
2,8,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0013, "CMP0013",
"Duplicate binary directories are not allowed.",
2,8,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0014, "CMP0014",
"Input directories must have CMakeLists.txt.",
2,8,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0015, "CMP0015",
"link_directories() treats paths relative to the source dir.",
2,8,1, cmPolicies::WARN);
this->DefinePolicy(
CMP0016, "CMP0016",
"target_link_libraries() reports error if its only argument "
"is not a target.",
2,8,3, cmPolicies::WARN);
this->DefinePolicy(
CMP0017, "CMP0017",
"Prefer files from the CMake module directory when including from there.",
2,8,4, cmPolicies::WARN);
this->DefinePolicy(
CMP0018, "CMP0018",
"Ignore CMAKE_SHARED_LIBRARY_<Lang>_FLAGS variable.",
2,8,9, cmPolicies::WARN);
this->DefinePolicy(
CMP0019, "CMP0019",
"Do not re-expand variables in include and link information.",
2,8,11, cmPolicies::WARN);
this->DefinePolicy(
CMP0020, "CMP0020",
"Automatically link Qt executables to qtmain target on Windows.",
2,8,11, cmPolicies::WARN);
this->DefinePolicy(
CMP0021, "CMP0021",
"Fatal error on relative paths in INCLUDE_DIRECTORIES target property.",
2,8,12, cmPolicies::WARN);
this->DefinePolicy(
CMP0022, "CMP0022",
"INTERFACE_LINK_LIBRARIES defines the link interface.",
2,8,12, cmPolicies::WARN);
this->DefinePolicy(
CMP0023, "CMP0023",
"Plain and keyword target_link_libraries signatures cannot be mixed.",
2,8,12, cmPolicies::WARN);
this->DefinePolicy(
CMP0024, "CMP0024",
"Disallow include export result.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0025, "CMP0025",
"Compiler id for Apple Clang is now AppleClang.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0026, "CMP0026",
"Disallow use of the LOCATION target property.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0027, "CMP0027",
"Conditionally linked imported targets with missing include directories.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0028, "CMP0028",
"Double colon in target name means ALIAS or IMPORTED target.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0029, "CMP0029",
"The subdir_depends command should not be called.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0030, "CMP0030",
"The use_mangled_mesa command should not be called.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0031, "CMP0031",
"The load_command command should not be called.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0032, "CMP0032",
"The output_required_files command should not be called.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0033, "CMP0033",
"The export_library_dependencies command should not be called.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0034, "CMP0034",
"The utility_source command should not be called.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0035, "CMP0035",
"The variable_requires command should not be called.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0036, "CMP0036",
"The build_name command should not be called.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0037, "CMP0037",
"Target names should not be reserved and should match a validity pattern.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0038, "CMP0038",
"Targets may not link directly to themselves.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0039, "CMP0039",
"Utility targets may not have link dependencies.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0040, "CMP0040",
"The target in the TARGET signature of add_custom_command() must exist.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0041, "CMP0041",
"Error on relative include with generator expression.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0042, "CMP0042",
"MACOSX_RPATH is enabled by default.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0043, "CMP0043",
"Ignore COMPILE_DEFINITIONS_<Config> properties.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0044, "CMP0044",
"Case sensitive <LANG>_COMPILER_ID generator expressions.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0045, "CMP0045",
"Error on non-existent target in get_target_property.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0046, "CMP0046",
"Error on non-existent dependency in add_dependencies.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0047, "CMP0047",
"Use QCC compiler id for the qcc drivers on QNX.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0048, "CMP0048",
"project() command manages VERSION variables.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0049, "CMP0049",
"Do not expand variables in target source entries.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0050, "CMP0050",
"Disallow add_custom_command SOURCE signatures.",
3,0,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0051, "CMP0051",
"List TARGET_OBJECTS in SOURCES target property.",
3,1,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0052, "CMP0052",
"Reject source and build dirs in installed "
"INTERFACE_INCLUDE_DIRECTORIES.",
3,1,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0053, "CMP0053",
"Simplify variable reference and escape sequence evaluation.",
3,1,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0054, "CMP0054",
"Only interpret if() arguments as variables or keywords when unquoted.",
3,1,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0055, "CMP0055",
"Strict checking for break() command.",
3,2,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0056, "CMP0056",
"Honor link flags in try_compile() source-file signature.",
3,2,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0058, "CMP0058",
"Ninja requires custom command byproducts to be explicit.",
3,3,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0059, "CMP0059",
"Do no treat DEFINITIONS as a built-in directory property.",
3,3,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0060, "CMP0060",
"Link libraries by full path even in implicit directories.",
3,3,0, cmPolicies::WARN);
this->DefinePolicy(
CMP0057, "CMP0057",
"Support new IN_LIST if() operator.",
3,3,0, cmPolicies::WARN);
std::ostringstream e;
e << "The project requests behavior compatible with CMake version \""
<< majorVer << "." << minorVer << "." << patchVer
<< "\", which requires the OLD behavior for some policies:\n";
for(std::vector<cmPolicies::PolicyID>::const_iterator
i = ancient.begin(); i != ancient.end(); ++i)
{
e << " " << idToString(*i) << ": " << idToShortDescription(*i) << "\n";
}
e << "However, this version of CMake no longer supports the OLD "
<< "behavior for these policies. "
<< "Please either update your CMakeLists.txt files to conform to "
<< "the new behavior or use an older version of CMake that still "
<< "supports the old behavior.";
mf->IssueMessage(cmake::FATAL_ERROR, e.str());
}
cmPolicies::~cmPolicies()
//----------------------------------------------------------------------------
static bool GetPolicyDefault(cmMakefile* mf, std::string const& policy,
cmPolicies::PolicyStatus* defaultSetting)
{
cmDeleteAll(this->Policies);
std::string defaultVar = "CMAKE_POLICY_DEFAULT_" + policy;
std::string defaultValue = mf->GetSafeDefinition(defaultVar);
if(defaultValue == "NEW")
{
*defaultSetting = cmPolicies::NEW;
}
else if(defaultValue == "OLD")
{
*defaultSetting = cmPolicies::OLD;
}
else if(defaultValue == "")
{
*defaultSetting = cmPolicies::WARN;
}
else
{
std::ostringstream e;
e << defaultVar << " has value \"" << defaultValue
<< "\" but must be \"OLD\", \"NEW\", or \"\" (empty).";
mf->IssueMessage(cmake::FATAL_ERROR, e.str());
return false;
}
void cmPolicies::DefinePolicy(cmPolicies::PolicyID iD,
const char *idString,
const char *shortDescription,
unsigned int majorVersionIntroduced,
unsigned int minorVersionIntroduced,
unsigned int patchVersionIntroduced,
cmPolicies::PolicyStatus status)
{
// a policy must be unique and can only be defined once
if (this->Policies.find(iD) != this->Policies.end())
{
cmSystemTools::Error("Attempt to redefine a CMake policy for policy "
"ID ", this->GetPolicyIDString(iD).c_str());
return;
}
this->Policies[iD] = new cmPolicy(iD, idString,
shortDescription,
majorVersionIntroduced,
minorVersionIntroduced,
patchVersionIntroduced,
status);
this->PolicyStringMap[idString] = iD;
return true;
}
//----------------------------------------------------------------------------
@ -489,20 +238,20 @@ bool cmPolicies::ApplyPolicyVersion(cmMakefile *mf,
// now loop over all the policies and set them as appropriate
std::vector<cmPolicies::PolicyID> ancientPolicies;
for(std::map<cmPolicies::PolicyID,cmPolicy *>::iterator i
= this->Policies.begin(); i != this->Policies.end(); ++i)
for(PolicyID pid = cmPolicies::CMP0000;
pid != cmPolicies::CMPCOUNT; pid = PolicyID(pid+1))
{
if (i->second->IsPolicyNewerThan(majorVer,minorVer,patchVer))
if (isPolicyNewerThan(pid, majorVer, minorVer, patchVer))
{
if(i->second->Status == cmPolicies::REQUIRED_ALWAYS)
if(cmPolicies::GetPolicyStatus(pid) == cmPolicies::REQUIRED_ALWAYS)
{
ancientPolicies.push_back(i->first);
ancientPolicies.push_back(pid);
}
else
{
cmPolicies::PolicyStatus status = cmPolicies::WARN;
if(!this->GetPolicyDefault(mf, i->second->IDString, &status) ||
!mf->SetPolicy(i->second->ID, status))
if(!GetPolicyDefault(mf, idToString(pid), &status) ||
!mf->SetPolicy(pid, status))
{
return false;
}
@ -510,7 +259,7 @@ bool cmPolicies::ApplyPolicyVersion(cmMakefile *mf,
}
else
{
if (!mf->SetPolicy(i->second->ID, cmPolicies::NEW))
if (!mf->SetPolicy(pid, cmPolicies::NEW))
{
return false;
}
@ -520,7 +269,7 @@ bool cmPolicies::ApplyPolicyVersion(cmMakefile *mf,
// Make sure the project does not use any ancient policies.
if(!ancientPolicies.empty())
{
this->DiagnoseAncientPolicies(ancientPolicies,
DiagnoseAncientPolicies(ancientPolicies,
majorVer, minorVer, patchVer, mf);
cmSystemTools::SetFatalErrorOccured();
return false;
@ -529,81 +278,19 @@ bool cmPolicies::ApplyPolicyVersion(cmMakefile *mf,
return true;
}
//----------------------------------------------------------------------------
bool cmPolicies::GetPolicyDefault(cmMakefile* mf, std::string const& policy,
cmPolicies::PolicyStatus* defaultSetting)
{
std::string defaultVar = "CMAKE_POLICY_DEFAULT_" + policy;
std::string defaultValue = mf->GetSafeDefinition(defaultVar);
if(defaultValue == "NEW")
{
*defaultSetting = cmPolicies::NEW;
}
else if(defaultValue == "OLD")
{
*defaultSetting = cmPolicies::OLD;
}
else if(defaultValue == "")
{
*defaultSetting = cmPolicies::WARN;
}
else
{
std::ostringstream e;
e << defaultVar << " has value \"" << defaultValue
<< "\" but must be \"OLD\", \"NEW\", or \"\" (empty).";
mf->IssueMessage(cmake::FATAL_ERROR, e.str());
return false;
}
return true;
}
bool cmPolicies::GetPolicyID(const char *id, cmPolicies::PolicyID &pid)
{
if (!id || strlen(id) < 1)
{
return false;
return stringToId(id, pid);
}
std::map<std::string,cmPolicies::PolicyID>::iterator pos =
this->PolicyStringMap.find(id);
if (pos == this->PolicyStringMap.end())
{
return false;
}
pid = pos->second;
return true;
}
std::string cmPolicies::GetPolicyIDString(cmPolicies::PolicyID pid)
{
std::map<cmPolicies::PolicyID,cmPolicy *>::iterator pos =
this->Policies.find(pid);
if (pos == this->Policies.end())
{
return "";
}
return pos->second->IDString;
}
///! return a warning string for a given policy
std::string cmPolicies::GetPolicyWarning(cmPolicies::PolicyID id)
{
std::map<cmPolicies::PolicyID,cmPolicy *>::iterator pos =
this->Policies.find(id);
if (pos == this->Policies.end())
{
cmSystemTools::Error(
"Request for warning text for undefined policy!");
return "Request for warning text for undefined policy!";
}
std::ostringstream msg;
msg <<
"Policy " << pos->second->IDString << " is not set: "
"" << pos->second->ShortDescription << " "
"Run \"cmake --help-policy " << pos->second->IDString << "\" for "
"Policy " << idToString(id) << " is not set: "
"" << idToShortDescription(id) << " "
"Run \"cmake --help-policy " << idToString(id) << "\" for "
"policy details. "
"Use the cmake_policy command to set the policy "
"and suppress this warning.";
@ -614,26 +301,17 @@ std::string cmPolicies::GetPolicyWarning(cmPolicies::PolicyID id)
///! return an error string for when a required policy is unspecified
std::string cmPolicies::GetRequiredPolicyError(cmPolicies::PolicyID id)
{
std::map<cmPolicies::PolicyID,cmPolicy *>::iterator pos =
this->Policies.find(id);
if (pos == this->Policies.end())
{
cmSystemTools::Error(
"Request for error text for undefined policy!");
return "Request for error text for undefined policy!";
}
std::ostringstream error;
error <<
"Policy " << pos->second->IDString << " is not set to NEW: "
"" << pos->second->ShortDescription << " "
"Run \"cmake --help-policy " << pos->second->IDString << "\" for "
"Policy " << idToString(id) << " is not set to NEW: "
"" << idToShortDescription(id) << " "
"Run \"cmake --help-policy " << idToString(id) << "\" for "
"policy details. "
"CMake now requires this policy to be set to NEW by the project. "
"The policy may be set explicitly using the code\n"
" cmake_policy(SET " << pos->second->IDString << " NEW)\n"
" cmake_policy(SET " << idToString(id) << " NEW)\n"
"or by upgrading all policies with the code\n"
" cmake_policy(VERSION " << pos->second->GetVersionString() <<
" cmake_policy(VERSION " << idToVersion(id) <<
") # or later\n"
"Run \"cmake --help-command cmake_policy\" for more information.";
return error.str();
@ -641,30 +319,21 @@ std::string cmPolicies::GetRequiredPolicyError(cmPolicies::PolicyID id)
///! Get the default status for a policy
cmPolicies::PolicyStatus
cmPolicies::GetPolicyStatus(cmPolicies::PolicyID id)
cmPolicies::GetPolicyStatus(cmPolicies::PolicyID)
{
// if the policy is not know then what?
std::map<cmPolicies::PolicyID,cmPolicy *>::iterator pos =
this->Policies.find(id);
if (pos == this->Policies.end())
{
// TODO is this right?
return cmPolicies::WARN;
}
return pos->second->Status;
}
//----------------------------------------------------------------------------
std::string
cmPolicies::GetRequiredAlwaysPolicyError(cmPolicies::PolicyID id)
{
std::string pid = this->GetPolicyIDString(id);
std::string pid = idToString(id);
std::ostringstream e;
e << "Policy " << pid << " may not be set to OLD behavior because this "
<< "version of CMake no longer supports it. "
<< "The policy was introduced in "
<< "CMake version " << this->Policies[id]->GetVersionString()
<< "CMake version " << idToVersion(id)
<< ", and use of NEW behavior is now required."
<< "\n"
<< "Please either update your CMakeLists.txt files to conform to "
@ -674,28 +343,51 @@ cmPolicies::GetRequiredAlwaysPolicyError(cmPolicies::PolicyID id)
return e.str();
}
//----------------------------------------------------------------------------
void
cmPolicies::DiagnoseAncientPolicies(std::vector<PolicyID> const& ancient,
unsigned int majorVer,
unsigned int minorVer,
unsigned int patchVer,
cmMakefile* mf)
cmPolicies::PolicyMap::PolicyMap()
{
std::ostringstream e;
e << "The project requests behavior compatible with CMake version \""
<< majorVer << "." << minorVer << "." << patchVer
<< "\", which requires the OLD behavior for some policies:\n";
for(std::vector<PolicyID>::const_iterator
i = ancient.begin(); i != ancient.end(); ++i)
this->UNDEFINED.set();
}
cmPolicies::PolicyStatus
cmPolicies::PolicyMap::Get(cmPolicies::PolicyID id) const
{
cmPolicy const* policy = this->Policies[*i];
e << " " << policy->IDString << ": " << policy->ShortDescription << "\n";
PolicyStatus status = cmPolicies::WARN;
if (this->OLD[id])
{
status = cmPolicies::OLD;
}
e << "However, this version of CMake no longer supports the OLD "
<< "behavior for these policies. "
<< "Please either update your CMakeLists.txt files to conform to "
<< "the new behavior or use an older version of CMake that still "
<< "supports the old behavior.";
mf->IssueMessage(cmake::FATAL_ERROR, e.str());
else if (this->NEW[id])
{
status = cmPolicies::NEW;
}
else if (this->REQUIRED_ALWAYS[id])
{
status = cmPolicies::REQUIRED_ALWAYS;
}
else if (this->REQUIRED_IF_USED[id])
{
status = cmPolicies::REQUIRED_IF_USED;
}
return status;
}
void cmPolicies::PolicyMap::Set(cmPolicies::PolicyID id,
cmPolicies::PolicyStatus status)
{
this->UNDEFINED.reset(id);
this->OLD[id] = (status == cmPolicies::OLD);
this->NEW[id] = (status == cmPolicies::NEW);
this->REQUIRED_ALWAYS[id] = (status == cmPolicies::REQUIRED_ALWAYS);
this->REQUIRED_IF_USED[id] = (status == cmPolicies::REQUIRED_IF_USED);
}
bool cmPolicies::PolicyMap::IsDefined(cmPolicies::PolicyID id) const
{
return !this->UNDEFINED[id];
}
bool cmPolicies::PolicyMap::IsEmpty() const
{
return !this->UNDEFINED.none();
}

325
Source/cmPolicies.h
View File

@ -14,10 +14,207 @@
#include "cmCustomCommand.h"
class cmake;
#include <bitset>
class cmMakefile;
class cmPolicy;
#define CM_FOR_EACH_POLICY_TABLE(POLICY, SELECT) \
SELECT(POLICY, CMP0000, \
"A minimum required CMake version must be specified.", \
2, 6, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0001, \
"CMAKE_BACKWARDS_COMPATIBILITY should no longer be used.", \
2, 6, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0002, \
"Logical target names must be globally unique.", \
2, 6, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0003, \
"Libraries linked via full path no longer produce linker search paths.", \
2, 6, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0004, \
"Libraries linked may not have leading or trailing whitespace.", \
2, 6, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0005, \
"Preprocessor definition values are now escaped automatically.", \
2, 6, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0006, \
"Installing MACOSX_BUNDLE targets requires a BUNDLE DESTINATION.", \
2, 6, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0007, \
"list command no longer ignores empty elements.", \
2, 6, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0008, \
"Libraries linked by full-path must have a valid library file name.", \
2, 6, 1, cmPolicies::WARN) \
SELECT(POLICY, CMP0009, \
"FILE GLOB_RECURSE calls should not follow symlinks by default.", \
2, 6, 2, cmPolicies::WARN) \
SELECT(POLICY, CMP0010, \
"Bad variable reference syntax is an error.", \
2, 6, 3, cmPolicies::WARN) \
SELECT(POLICY, CMP0011, \
"Included scripts do automatic cmake_policy PUSH and POP.", \
2, 6, 3, cmPolicies::WARN) \
SELECT(POLICY, CMP0012, \
"if() recognizes numbers and boolean constants.", \
2, 8, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0013, \
"Duplicate binary directories are not allowed.", \
2, 8, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0014, \
"Input directories must have CMakeLists.txt.", \
2, 8, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0015, \
"link_directories() treats paths relative to the source dir.", \
2, 8, 1, cmPolicies::WARN) \
SELECT(POLICY, CMP0016, \
"target_link_libraries() reports error if its only argument " \
"is not a target.", \
2, 8, 3, cmPolicies::WARN) \
SELECT(POLICY, CMP0017, \
"Prefer files from the CMake module directory when including from " \
"there.", \
2, 8, 4, cmPolicies::WARN) \
SELECT(POLICY, CMP0018, \
"Ignore CMAKE_SHARED_LIBRARY_<Lang>_FLAGS variable.", \
2, 8, 9, cmPolicies::WARN) \
SELECT(POLICY, CMP0019, \
"Do not re-expand variables in include and link information.", \
2, 8, 11, cmPolicies::WARN) \
SELECT(POLICY, CMP0020, \
"Automatically link Qt executables to qtmain target on Windows.", \
2, 8, 11, cmPolicies::WARN) \
SELECT(POLICY, CMP0021, \
"Fatal error on relative paths in INCLUDE_DIRECTORIES target property.", \
2, 8, 12, cmPolicies::WARN) \
SELECT(POLICY, CMP0022, \
"INTERFACE_LINK_LIBRARIES defines the link interface.", \
2, 8, 12, cmPolicies::WARN) \
SELECT(POLICY, CMP0023, \
"Plain and keyword target_link_libraries signatures cannot be mixed.", \
2, 8, 12, cmPolicies::WARN) \
SELECT(POLICY, CMP0024, \
"Disallow include export result.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0025, \
"Compiler id for Apple Clang is now AppleClang.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0026, \
"Disallow use of the LOCATION target property.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0027, \
"Conditionally linked imported targets with missing include " \
"directories.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0028, \
"Double colon in target name means ALIAS or IMPORTED target.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0029, \
"The subdir_depends command should not be called.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0030, \
"The use_mangled_mesa command should not be called.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0031, \
"The load_command command should not be called.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0032, \
"The output_required_files command should not be called.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0033, \
"The export_library_dependencies command should not be called.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0034, \
"The utility_source command should not be called.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0035, \
"The variable_requires command should not be called.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0036, \
"The build_name command should not be called.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0037, \
"Target names should not be reserved and should match a validity " \
"pattern.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0038, \
"Targets may not link directly to themselves.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0039, \
"Utility targets may not have link dependencies.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0040, \
"The target in the TARGET signature of add_custom_command() must " \
"exist.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0041, \
"Error on relative include with generator expression.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0042, \
"MACOSX_RPATH is enabled by default.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0043, \
"Ignore COMPILE_DEFINITIONS_<Config> properties.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0044, \
"Case sensitive <LANG>_COMPILER_ID generator expressions.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0045, \
"Error on non-existent target in get_target_property.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0046, \
"Error on non-existent dependency in add_dependencies.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0047, \
"Use QCC compiler id for the qcc drivers on QNX.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0048, \
"project() command manages VERSION variables.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0049, \
"Do not expand variables in target source entries.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0050, \
"Disallow add_custom_command SOURCE signatures.", \
3, 0, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0051, \
"List TARGET_OBJECTS in SOURCES target property.", \
3, 1, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0052, \
"Reject source and build dirs in installed " \
"INTERFACE_INCLUDE_DIRECTORIES.", \
3, 1, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0053, \
"Simplify variable reference and escape sequence evaluation.", \
3, 1, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0054, \
"Only interpret if() arguments as variables or keywords when unquoted.", \
3, 1, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0055, \
"Strict checking for break() command.", \
3, 2, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0056, \
"Honor link flags in try_compile() source-file signature.", \
3, 2, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0057, \
"Support new IN_LIST if() operator.", \
3, 3, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0058, \
"Ninja requires custom command byproducts to be explicit.", \
3, 3, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0059, \
"Do no treat DEFINITIONS as a built-in directory property.", \
3, 3, 0, cmPolicies::WARN) \
SELECT(POLICY, CMP0060, \
"Link libraries by full path even in implicit directories.", \
3, 3, 0, cmPolicies::WARN)
#define CM_SELECT_ID(F, A1, A2, A3, A4, A5, A6) F(A1)
#define CM_FOR_EACH_POLICY_ID(POLICY) \
CM_FOR_EACH_POLICY_TABLE(POLICY, CM_SELECT_ID)
/** \class cmPolicies
* \brief Handles changes in CMake behavior and policies
*
@ -28,9 +225,6 @@ class cmPolicy;
class cmPolicies
{
public:
cmPolicies();
~cmPolicies();
/// Status of a policy
enum PolicyStatus {
OLD, ///< Use old behavior
@ -41,83 +235,13 @@ public:
REQUIRED_IF_USED,
REQUIRED_ALWAYS ///< Issue an error unless user sets policy status to NEW.
};
static const char* PolicyStatusNames[];
/// Policy identifiers
enum PolicyID
{
CMP0000, ///< Policy version specification
CMP0001, ///< Ignore old compatibility variable
CMP0002, ///< Target names must be unique
CMP0003, ///< Linking does not include extra -L paths
CMP0004, ///< Libraries linked may not have leading or trailing whitespace
CMP0005, ///< Definition value escaping
CMP0006, ///< BUNDLE install rules needed for MACOSX_BUNDLE targets
CMP0007, ///< list command handling of empty elements
CMP0008, ///< Full-path libraries must be a valid library file name
CMP0009, ///< GLOB_RECURSE should not follow symlinks by default
CMP0010, ///< Bad variable reference syntax is an error
CMP0011, ///< Strong policy scope for include and find_package
CMP0012, ///< Recognize numbers and boolean constants in if()
CMP0013, ///< Duplicate binary directories not allowed
CMP0014, ///< Input directories must have CMakeLists.txt
CMP0015, ///< link_directories() treats paths relative to source dir
/// target_link_libraries() fails if only argument is not a target
CMP0016,
CMP0017, ///< Prefer files in CMAKE_ROOT when including from CMAKE_ROOT
CMP0018, ///< Ignore language flags for shared libs, and adhere to
/// POSITION_INDEPENDENT_CODE property and *_COMPILE_OPTIONS_PI{E,C}
/// instead.
CMP0019, ///< No variable re-expansion in include and link info
CMP0020, ///< Automatically link Qt executables to qtmain target
CMP0021, ///< Fatal error on relative paths in INCLUDE_DIRECTORIES
/// target property
CMP0022, ///< INTERFACE_LINK_LIBRARIES defines the link interface
CMP0023, ///< Disallow mixing keyword and plain tll signatures
CMP0024, ///< Disallow including export() result.
CMP0025, ///< Compiler id for Apple Clang is now AppleClang
CMP0026, ///< Disallow use of the LOCATION target property.
CMP0027, ///< Conditionally linked imported targets with missing include
/// directories.
CMP0028, ///< Double colon in target name means ALIAS or IMPORTED target.
CMP0029, ///< Disallow command: subdir_depends
CMP0030, ///< Disallow command: use_mangled_mesa
CMP0031, ///< Disallow command: load_command
CMP0032, ///< Disallow command: output_required_files
CMP0033, ///< Disallow command: export_library_dependencies
CMP0034, ///< Disallow command: utility_source
CMP0035, ///< Disallow command: variable_requires
CMP0036, ///< Disallow command: build_name
CMP0037, ///< Target names should not be reserved and
/// should match a validity pattern.
CMP0038, ///< Targets may not link directly to themselves
CMP0039, ///< Utility targets may not have link dependencies
CMP0040, ///< The target in the TARGET signature of
/// add_custom_command() must exist.
CMP0041, ///< Error on relative include with generator expression
CMP0042, ///< Enable MACOSX_RPATH by default
CMP0043, ///< Ignore COMPILE_DEFINITIONS_<Config> properties
CMP0044, ///< Case sensitive <LANG>_COMPILER_ID generator expressions
CMP0045, ///< Error on non-existent target in get_target_property
CMP0046, ///< Error on non-existent dependency in add_dependencies
CMP0047, ///< Use QCC compiler id for the qcc drivers on QNX.
CMP0048, ///< project() command manages VERSION variables
CMP0049, ///< Do not expand variables in target source entries
CMP0050, ///< Disallow add_custom_command SOURCE signatures
CMP0051, ///< List TARGET_OBJECTS in SOURCES target property
CMP0052, ///< Reject source and build dirs in installed
/// INTERFACE_INCLUDE_DIRECTORIES
CMP0053, ///< Simplify variable reference and escape sequence evaluation
CMP0054, ///< Only interpret if() arguments as variables
/// or keywords when unquoted.
CMP0055, ///< Strict checking for break() command.
CMP0056, ///< Honor link flags in try_compile() source-file signature.
CMP0058, ///< Ninja requires custom command byproducts to be explicit
CMP0059, ///< Do not treat ``DEFINITIONS`` as a built-in directory
/// property.
CMP0060, ///< Link libraries by full path even in implicit directories.
CMP0057, ///< Support new IN_LIST if() operator.
#define POLICY_ENUM(POLICY_ID) POLICY_ID,
CM_FOR_EACH_POLICY_ID(POLICY_ENUM)
#undef POLICY_ENUM
/** \brief Always the last entry.
*
@ -128,48 +252,39 @@ public:
};
///! convert a string policy ID into a number
bool GetPolicyID(const char *id, /* out */ cmPolicies::PolicyID &pid);
std::string GetPolicyIDString(cmPolicies::PolicyID pid);
static bool GetPolicyID(const char *id, /* out */ cmPolicies::PolicyID &pid);
///! Get the default status for a policy
cmPolicies::PolicyStatus GetPolicyStatus(cmPolicies::PolicyID id);
///! Define a Policy for CMake
void DefinePolicy(cmPolicies::PolicyID id,
const char *stringID,
const char *shortDescription,
unsigned int majorVersionIntroduced,
unsigned int minorVersionIntroduced,
unsigned int patchVersionIntroduced,
cmPolicies::PolicyStatus status);
static cmPolicies::PolicyStatus GetPolicyStatus(cmPolicies::PolicyID id);
///! Set a policy level for this listfile
bool ApplyPolicyVersion(cmMakefile *mf, const char *version);
static bool ApplyPolicyVersion(cmMakefile *mf, const char *version);
///! return a warning string for a given policy
std::string GetPolicyWarning(cmPolicies::PolicyID id);
static std::string GetPolicyWarning(cmPolicies::PolicyID id);
///! return an error string for when a required policy is unspecified
std::string GetRequiredPolicyError(cmPolicies::PolicyID id);
static std::string GetRequiredPolicyError(cmPolicies::PolicyID id);
///! return an error string for when a required policy is unspecified
std::string GetRequiredAlwaysPolicyError(cmPolicies::PolicyID id);
static std::string GetRequiredAlwaysPolicyError(cmPolicies::PolicyID id);
/** Represent a set of policy values. */
typedef std::map<PolicyID, PolicyStatus> PolicyMap;
struct PolicyMap
{
PolicyMap();
PolicyStatus Get(PolicyID id) const;
void Set(PolicyID id, PolicyStatus status);
bool IsDefined(PolicyID id) const;
bool IsEmpty() const;
private:
// might have to make these internal for VS6 not sure yet
std::map<PolicyID,cmPolicy *> Policies;
std::map<std::string,PolicyID> PolicyStringMap;
void DiagnoseAncientPolicies(std::vector<PolicyID> const& ancient,
unsigned int majorVer, unsigned int minorVer,
unsigned int patchVer, cmMakefile* mf);
bool GetPolicyDefault(cmMakefile* mf, std::string const& policy,
cmPolicies::PolicyStatus* defaultStatus);
std::bitset<cmPolicies::CMPCOUNT> UNDEFINED;
std::bitset<cmPolicies::CMPCOUNT> OLD;
std::bitset<cmPolicies::CMPCOUNT> NEW;
std::bitset<cmPolicies::CMPCOUNT> REQUIRED_IF_USED;
std::bitset<cmPolicies::CMPCOUNT> REQUIRED_ALWAYS;
};
};
#endif

3
Source/cmProjectCommand.cxx
View File

@ -216,8 +216,7 @@ bool cmProjectCommand
if(!vw.empty())
{
std::ostringstream w;
w << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0048))
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0048)
<< "\nThe following variable(s) would be set to empty:" << vw;
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
}

38
Source/cmTarget.cxx
View File

@ -973,8 +973,7 @@ std::string cmTarget::ProcessSourceItemCMP0049(const std::string& s)
switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0049))
{
case cmPolicies::WARN:
e << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0049)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0049) << "\n";
break;
case cmPolicies::OLD:
noMessage = true;
@ -2007,8 +2006,7 @@ static void processIncludeDirectories(cmTarget const* tgt,
switch(tgt->GetPolicyStatusCMP0027())
{
case cmPolicies::WARN:
e << (mf->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0027)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0027) << "\n";
case cmPolicies::OLD:
messageType = cmake::AUTHOR_WARNING;
break;
@ -2048,8 +2046,7 @@ static void processIncludeDirectories(cmTarget const* tgt,
{
case cmPolicies::WARN:
{
e << (mf->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0021)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0021) << "\n";
messageType = cmake::AUTHOR_WARNING;
}
break;
@ -2397,8 +2394,7 @@ void cmTarget::GetCompileDefinitions(std::vector<std::string> &list,
case cmPolicies::WARN:
{
std::ostringstream e;
e << this->Makefile->GetCMakeInstance()->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0043);
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0043);
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,
e.str());
}
@ -2873,8 +2869,7 @@ bool cmTarget::HandleLocationPropertyPolicy(cmMakefile* context) const
switch (context->GetPolicyStatus(cmPolicies::CMP0026))
{
case cmPolicies::WARN:
e << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0026)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0026) << "\n";
modal = "should";
case cmPolicies::OLD:
break;
@ -3137,8 +3132,7 @@ const char *cmTarget::GetProperty(const std::string& prop,
switch(context->GetPolicyStatus(cmPolicies::CMP0051))
{
case cmPolicies::WARN:
e << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0051)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0051) << "\n";
noMessage = false;
case cmPolicies::OLD:
break;
@ -3235,8 +3229,7 @@ public:
{
case cmPolicies::WARN:
{
e << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0028)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0028) << "\n";
messageType = cmake::AUTHOR_WARNING;
}
break;
@ -5991,9 +5984,7 @@ cmTargetInternals::ComputeLinkInterfaceLibraries(
&& strcmp(newExplicitLibraries, explicitLibraries) != 0)
{
std::ostringstream w;
w <<
(thisTarget->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0022)) << "\n"
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0022) << "\n"
"Target \"" << thisTarget->GetName() << "\" has an "
"INTERFACE_LINK_LIBRARIES property which differs from its " <<
linkIfaceProp << " properties."
@ -6062,9 +6053,7 @@ cmTargetInternals::ComputeLinkInterfaceLibraries(
{ newLibraries = "(empty)"; }
std::ostringstream w;
w <<
(thisTarget->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0022)) << "\n"
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0022) << "\n"
"Target \"" << thisTarget->GetName() << "\" has an "
"INTERFACE_LINK_LIBRARIES property. "
"This should be preferred as the source of the link interface "
@ -6321,8 +6310,7 @@ cmTargetInternals::ComputeLinkImplementationLibraries(
{
case cmPolicies::WARN:
{
e << (thisTarget->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0038)) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0038) << "\n";
messageType = cmake::AUTHOR_WARNING;
}
break;
@ -6459,8 +6447,7 @@ std::string cmTarget::CheckCMP0004(std::string const& item) const
case cmPolicies::WARN:
{
std::ostringstream w;
w << (this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0004)) << "\n"
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0004) << "\n"
<< "Target \"" << this->GetName() << "\" links to item \""
<< item << "\" which has leading or trailing whitespace.";
cm->IssueMessage(cmake::AUTHOR_WARNING, w.str(),
@ -6481,8 +6468,7 @@ std::string cmTarget::CheckCMP0004(std::string const& item) const
case cmPolicies::REQUIRED_ALWAYS:
{
std::ostringstream e;
e << (this->Makefile->GetPolicies()
->GetRequiredPolicyError(cmPolicies::CMP0004)) << "\n"
e << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0004) << "\n"
<< "Target \"" << this->GetName() << "\" links to item \""
<< item << "\" which has leading or trailing whitespace.";
cm->IssueMessage(cmake::FATAL_ERROR, e.str(), this->GetBacktrace());

12
Source/cmTargetLinkLibrariesCommand.cxx
View File

@ -58,16 +58,14 @@ bool cmTargetLinkLibrariesCommand
e << "\n"
<< "CMake does not support this but it used to work accidentally "
<< "and is being allowed for compatibility."
<< "\n" << this->Makefile->GetPolicies()->
GetPolicyWarning(cmPolicies::CMP0016);
<< "\n" << cmPolicies::GetPolicyWarning(cmPolicies::CMP0016);
break;
case cmPolicies::OLD: // OLD behavior does not warn.
t = cmake::MESSAGE;
break;
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
e << "\n" << this->Makefile->GetPolicies()->
GetRequiredPolicyError(cmPolicies::CMP0016);
e << "\n" << cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0016);
break;
case cmPolicies::NEW: // NEW behavior prints the error.
break;
@ -108,8 +106,7 @@ bool cmTargetLinkLibrariesCommand
switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0039))
{
case cmPolicies::WARN:
e << this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0039) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0039) << "\n";
modal = "should";
case cmPolicies::OLD:
break;
@ -379,8 +376,7 @@ cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib,
switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0023))
{
case cmPolicies::WARN:
e << this->Makefile->GetPolicies()
->GetPolicyWarning(cmPolicies::CMP0023) << "\n";
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0023) << "\n";
modal = "should";
case cmPolicies::OLD:
break;