Kitware/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2025-10-16 14:08:35 +08:00
Code Issues Projects Releases Wiki Activity

cmCommand refactor: cmCMakePolicyCommand

Browse Source
This commit is contained in:
Gabor Bencze
2019-08-09 12:09:39 +02:00
committed by Brad King
parent 07ea93de54
commit 9413952c42
4 changed files with 66 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
Source/cmCMakePolicyCommand.cxx
View File

@@ -4,88 +4,101 @@
#include <sstream> #include <sstream>
#include "cmExecutionStatus.h"
#include "cmMakefile.h" #include "cmMakefile.h"
#include "cmMessageType.h" #include "cmMessageType.h"
#include "cmPolicies.h" #include "cmPolicies.h"
#include "cmState.h" #include "cmState.h"
#include "cmStateTypes.h" #include "cmStateTypes.h"
class cmExecutionStatus; namespace {
bool HandleSetMode(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleGetMode(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleVersionMode(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleGetWarningMode(std::vector<std::string> const& args,
cmExecutionStatus& status);
}
// cmCMakePolicyCommand // cmCMakePolicyCommand
bool cmCMakePolicyCommand::InitialPass(std::vector<std::string> const& args, bool cmCMakePolicyCommand(std::vector<std::string> const& args,
cmExecutionStatus&) cmExecutionStatus& status)
{ {
if (args.empty()) { if (args.empty()) {
this->SetError("requires at least one argument."); status.SetError("requires at least one argument.");
return false; return false;
} }
if (args[0] == "SET") { if (args[0] == "SET") {
return this->HandleSetMode(args); return HandleSetMode(args, status);
} }
if (args[0] == "GET") { if (args[0] == "GET") {
return this->HandleGetMode(args); return HandleGetMode(args, status);
} }
if (args[0] == "PUSH") { if (args[0] == "PUSH") {
if (args.size() > 1) { if (args.size() > 1) {
this->SetError("PUSH may not be given additional arguments."); status.SetError("PUSH may not be given additional arguments.");
return false; return false;
} }
this->Makefile->PushPolicy(); status.GetMakefile().PushPolicy();
return true; return true;
} }
if (args[0] == "POP") { if (args[0] == "POP") {
if (args.size() > 1) { if (args.size() > 1) {
this->SetError("POP may not be given additional arguments."); status.SetError("POP may not be given additional arguments.");
return false; return false;
} }
this->Makefile->PopPolicy(); status.GetMakefile().PopPolicy();
return true; return true;
} }
if (args[0] == "VERSION") { if (args[0] == "VERSION") {
return this->HandleVersionMode(args); return HandleVersionMode(args, status);
} }
if (args[0] == "GET_WARNING") { if (args[0] == "GET_WARNING") {
return this->HandleGetWarningMode(args); return HandleGetWarningMode(args, status);
} }
std::ostringstream e; std::ostringstream e;
e << "given unknown first argument \"" << args[0] << "\""; e << "given unknown first argument \"" << args[0] << "\"";
this->SetError(e.str()); status.SetError(e.str());
return false; return false;
} }
bool cmCMakePolicyCommand::HandleSetMode(std::vector<std::string> const& args) namespace {
bool HandleSetMode(std::vector<std::string> const& args,
cmExecutionStatus& status)
{ {
if (args.size() != 3) { if (args.size() != 3) {
this->SetError("SET must be given exactly 2 additional arguments."); status.SetError("SET must be given exactly 2 additional arguments.");
return false; return false;
} }
cmPolicies::PolicyStatus status; cmPolicies::PolicyStatus policyStatus;
if (args[2] == "OLD") { if (args[2] == "OLD") {
status = cmPolicies::OLD; policyStatus = cmPolicies::OLD;
} else if (args[2] == "NEW") { } else if (args[2] == "NEW") {
status = cmPolicies::NEW; policyStatus = cmPolicies::NEW;
} else { } else {
std::ostringstream e; std::ostringstream e;
e << "SET given unrecognized policy status \"" << args[2] << "\""; e << "SET given unrecognized policy status \"" << args[2] << "\"";
this->SetError(e.str()); status.SetError(e.str());
return false; return false;
} }
if (!this->Makefile->SetPolicy(args[1].c_str(), status)) { if (!status.GetMakefile().SetPolicy(args[1].c_str(), policyStatus)) {
this->SetError("SET failed to set policy."); status.SetError("SET failed to set policy.");
return false; return false;
} }
if (args[1] == "CMP0001" && if (args[1] == "CMP0001" &&
(status == cmPolicies::WARN || status == cmPolicies::OLD)) { (policyStatus == cmPolicies::WARN || policyStatus == cmPolicies::OLD)) {
if (!(this->Makefile->GetState()->GetInitializedCacheValue( if (!(status.GetMakefile().GetState()->GetInitializedCacheValue(
"CMAKE_BACKWARDS_COMPATIBILITY"))) { "CMAKE_BACKWARDS_COMPATIBILITY"))) {
// Set it to 2.4 because that is the last version where the // Set it to 2.4 because that is the last version where the
// variable had meaning. // variable had meaning.
this->Makefile->AddCacheDefinition( status.GetMakefile().AddCacheDefinition(
"CMAKE_BACKWARDS_COMPATIBILITY", "2.4", "CMAKE_BACKWARDS_COMPATIBILITY", "2.4",
"For backwards compatibility, what version of CMake " "For backwards compatibility, what version of CMake "
"commands and " "commands and "
@@ -96,14 +109,15 @@ bool cmCMakePolicyCommand::HandleSetMode(std::vector<std::string> const& args)
return true; return true;
} }
bool cmCMakePolicyCommand::HandleGetMode(std::vector<std::string> const& args) bool HandleGetMode(std::vector<std::string> const& args,
cmExecutionStatus& status)
{ {
bool parent_scope = false; bool parent_scope = false;
if (args.size() == 4 && args[3] == "PARENT_SCOPE") { if (args.size() == 4 && args[3] == "PARENT_SCOPE") {
// Undocumented PARENT_SCOPE option for use within CMake. // Undocumented PARENT_SCOPE option for use within CMake.
parent_scope = true; parent_scope = true;
} else if (args.size() != 3) { } else if (args.size() != 3) {
this->SetError("GET must be given exactly 2 additional arguments."); status.SetError("GET must be given exactly 2 additional arguments.");
return false; return false;
} }
@@ -117,25 +131,25 @@ bool cmCMakePolicyCommand::HandleGetMode(std::vector<std::string> const& args)
std::ostringstream e; std::ostringstream e;
e << "GET given policy \"" << id << "\" which is not known to this " e << "GET given policy \"" << id << "\" which is not known to this "
<< "version of CMake."; << "version of CMake.";
this->SetError(e.str()); status.SetError(e.str());
return false; return false;
} }
// Lookup the policy setting. // Lookup the policy setting.
cmPolicies::PolicyStatus status = cmPolicies::PolicyStatus policyStatus =
this->Makefile->GetPolicyStatus(pid, parent_scope); status.GetMakefile().GetPolicyStatus(pid, parent_scope);
switch (status) { switch (policyStatus) {
case cmPolicies::OLD: case cmPolicies::OLD:
// Report that the policy is set to OLD. // Report that the policy is set to OLD.
this->Makefile->AddDefinition(var, "OLD"); status.GetMakefile().AddDefinition(var, "OLD");
break; break;
case cmPolicies::WARN: case cmPolicies::WARN:
// Report that the policy is not set. // Report that the policy is not set.
this->Makefile->AddDefinition(var, ""); status.GetMakefile().AddDefinition(var, "");
break; break;
case cmPolicies::NEW: case cmPolicies::NEW:
// Report that the policy is set to NEW. // Report that the policy is set to NEW.
this->Makefile->AddDefinition(var, "NEW"); status.GetMakefile().AddDefinition(var, "NEW");
break; break;
case cmPolicies::REQUIRED_IF_USED: case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS: case cmPolicies::REQUIRED_ALWAYS:
@@ -146,22 +160,22 @@ bool cmCMakePolicyCommand::HandleGetMode(std::vector<std::string> const& args)
<< "The call to cmake_policy(GET " << id << " ...) at which this " << "The call to cmake_policy(GET " << id << " ...) at which this "
<< "error appears requests the policy, and this version of CMake " << "error appears requests the policy, and this version of CMake "
<< "requires that the policy be set to NEW before it is checked."; << "requires that the policy be set to NEW before it is checked.";
this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str()); status.GetMakefile().IssueMessage(MessageType::FATAL_ERROR, e.str());
} }
} }
return true; return true;
} }
bool cmCMakePolicyCommand::HandleVersionMode( bool HandleVersionMode(std::vector<std::string> const& args,
std::vector<std::string> const& args) cmExecutionStatus& status)
{ {
if (args.size() <= 1) { if (args.size() <= 1) {
this->SetError("VERSION not given an argument"); status.SetError("VERSION not given an argument");
return false; return false;
} }
if (args.size() >= 3) { if (args.size() >= 3) {
this->SetError("VERSION given too many arguments"); status.SetError("VERSION given too many arguments");
return false; return false;
} }
std::string const& version_string = args[1]; std::string const& version_string = args[1];
@@ -177,19 +191,19 @@ bool cmCMakePolicyCommand::HandleVersionMode(
std::ostringstream e; std::ostringstream e;
e << "VERSION \"" << version_string e << "VERSION \"" << version_string
<< R"(" does not have a version on both sides of "...".)"; << R"(" does not have a version on both sides of "...".)";
this->SetError(e.str()); status.SetError(e.str());
return false; return false;
} }
this->Makefile->SetPolicyVersion(version_min, version_max); status.GetMakefile().SetPolicyVersion(version_min, version_max);
return true; return true;
} }
bool cmCMakePolicyCommand::HandleGetWarningMode( bool HandleGetWarningMode(std::vector<std::string> const& args,
std::vector<std::string> const& args) cmExecutionStatus& status)
{ {
if (args.size() != 3) { if (args.size() != 3) {
this->SetError( status.SetError(
"GET_WARNING must be given exactly 2 additional arguments."); "GET_WARNING must be given exactly 2 additional arguments.");
return false; return false;
} }
@@ -204,12 +218,13 @@ bool cmCMakePolicyCommand::HandleGetWarningMode(
std::ostringstream e; std::ostringstream e;
e << "GET_WARNING given policy \"" << id e << "GET_WARNING given policy \"" << id
<< "\" which is not known to this version of CMake."; << "\" which is not known to this version of CMake.";
this->SetError(e.str()); status.SetError(e.str());
return false; return false;
} }
// Lookup the policy warning. // Lookup the policy warning.
this->Makefile->AddDefinition(var, cmPolicies::GetPolicyWarning(pid)); status.GetMakefile().AddDefinition(var, cmPolicies::GetPolicyWarning(pid));
return true; return true;
} }
}

32
Source/cmCMakePolicyCommand.h
View File

@@ -8,41 +8,15 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "cm_memory.hxx"
#include "cmCommand.h"
class cmExecutionStatus; class cmExecutionStatus;
/** \class cmCMakePolicyCommand /**
* \brief Set how CMake should handle policies * \brief Set how CMake should handle policies
* *
* cmCMakePolicyCommand sets how CMake should deal with backwards * cmCMakePolicyCommand sets how CMake should deal with backwards
* compatibility policies. * compatibility policies.
*/ */
class cmCMakePolicyCommand : public cmCommand bool cmCMakePolicyCommand(std::vector<std::string> const& args,
{ cmExecutionStatus& status);
public:
/**
* This is a virtual constructor for the command.
*/
std::unique_ptr<cmCommand> Clone() override
{
return cm::make_unique<cmCMakePolicyCommand>();
}
/**
* This is called when the command is first encountered in
* the CMakeLists.txt file.
*/
bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus& status) override;
private:
bool HandleSetMode(std::vector<std::string> const& args);
bool HandleGetMode(std::vector<std::string> const& args);
bool HandleVersionMode(std::vector<std::string> const& args);
bool HandleGetWarningMode(std::vector<std::string> const& args);
};
#endif #endif

3
Source/cmCommands.cxx
View File

@@ -118,8 +118,7 @@ void GetScriptingCommands(cmState* state)
{ {
state->AddBuiltinCommand("break", cmBreakCommand); state->AddBuiltinCommand("break", cmBreakCommand);
state->AddBuiltinCommand("cmake_minimum_required", cmCMakeMinimumRequired); state->AddBuiltinCommand("cmake_minimum_required", cmCMakeMinimumRequired);
state->AddBuiltinCommand("cmake_policy", state->AddBuiltinCommand("cmake_policy", cmCMakePolicyCommand);
cm::make_unique<cmCMakePolicyCommand>());
state->AddBuiltinCommand("configure_file", cmConfigureFileCommand); state->AddBuiltinCommand("configure_file", cmConfigureFileCommand);
state->AddBuiltinCommand("continue", cmContinueCommand); state->AddBuiltinCommand("continue", cmContinueCommand);
state->AddBuiltinCommand("exec_program", cmExecProgramCommand); state->AddBuiltinCommand("exec_program", cmExecProgramCommand);

3
Source/cmMakefile.h
View File

@@ -1002,7 +1002,8 @@ private:
cmPolicies::PolicyMap const& pm = cmPolicies::PolicyMap()); cmPolicies::PolicyMap const& pm = cmPolicies::PolicyMap());
void PopPolicy(); void PopPolicy();
void PopSnapshot(bool reportError = true); void PopSnapshot(bool reportError = true);
friend class cmCMakePolicyCommand; friend bool cmCMakePolicyCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
class IncludeScope; class IncludeScope;
friend class IncludeScope; friend class IncludeScope;