1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file LICENSE.rst or https://cmake.org/licensing for details. */
#include "cmCMakeMinimumRequired.h"
#include <cstdio>
#include <sstream>
#include "cmExecutionStatus.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmSystemTools.h"
#include "cmVersion.h"
namespace {
bool EnforceUnknownArguments(std::string const& version_max,
std::vector<std::string> const& unknown_arguments,
cmExecutionStatus& status);
}
// cmCMakeMinimumRequired
bool cmCMakeMinimumRequired(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
// Process arguments.
std::string version_string;
bool doing_version = false;
std::vector<std::string> unknown_arguments;
for (std::string const& arg : args) {
if (arg == "VERSION") {
doing_version = true;
} else if (arg == "FATAL_ERROR") {
if (doing_version) {
status.SetError("called with no value for VERSION.");
return false;
}
doing_version = false;
} else if (doing_version) {
doing_version = false;
version_string = arg;
} else {
unknown_arguments.push_back(arg);
}
}
if (doing_version) {
status.SetError("called with no value for VERSION.");
return false;
}
// Make sure there was a version to check.
if (version_string.empty()) {
return EnforceUnknownArguments(std::string(), unknown_arguments, status);
}
// Separate the <min> version and any trailing ...<max> component.
std::string::size_type const dd = version_string.find("...");
std::string const version_min = version_string.substr(0, dd);
std::string const version_max = dd != std::string::npos
? version_string.substr(dd + 3, std::string::npos)
: std::string();
if (dd != std::string::npos &&
(version_min.empty() || version_max.empty())) {
std::ostringstream e;
e << "VERSION \"" << version_string
<< R"(" does not have a version on both sides of "...".)";
status.SetError(e.str());
return false;
}
// Save the required version string.
status.GetMakefile().AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION",
version_min);
// Get the current version number.
unsigned int current_major = cmVersion::GetMajorVersion();
unsigned int current_minor = cmVersion::GetMinorVersion();
unsigned int current_patch = cmVersion::GetPatchVersion();
unsigned int current_tweak = cmVersion::GetTweakVersion();
// Parse at least two components of the version number.
// Use zero for those not specified.
unsigned int required_major = 0;
unsigned int required_minor = 0;
unsigned int required_patch = 0;
unsigned int required_tweak = 0;
if (sscanf(version_min.c_str(), "%u.%u.%u.%u", &required_major,
&required_minor, &required_patch, &required_tweak) < 2) {
std::ostringstream e;
e << "could not parse VERSION \"" << version_min << "\".";
status.SetError(e.str());
return false;
}
// Compare the version numbers.
if ((current_major < required_major) ||
(current_major == required_major && current_minor < required_minor) ||
(current_major == required_major && current_minor == required_minor &&
current_patch < required_patch) ||
(current_major == required_major && current_minor == required_minor &&
current_patch == required_patch && current_tweak < required_tweak)) {
// The current version is too low.
std::ostringstream e;
e << "CMake " << version_min
<< " or higher is required. You are running version "
<< cmVersion::GetCMakeVersion();
status.GetMakefile().IssueMessage(MessageType::FATAL_ERROR, e.str());
cmSystemTools::SetFatalErrorOccurred();
return true;
}
// The version is not from the future, so enforce unknown arguments.
if (!EnforceUnknownArguments(version_max, unknown_arguments, status)) {
return false;
}
if (required_major < 2 || (required_major == 2 && required_minor < 4)) {
status.GetMakefile().IssueMessage(
MessageType::AUTHOR_WARNING,
"Compatibility with CMake < 2.4 is not supported by CMake >= 3.0.");
status.GetMakefile().SetPolicyVersion("2.4", version_max);
} else {
status.GetMakefile().SetPolicyVersion(version_min, version_max);
}
return true;
}
namespace {
bool EnforceUnknownArguments(std::string const& version_max,
std::vector<std::string> const& unknown_arguments,
cmExecutionStatus& status)
{
if (unknown_arguments.empty()) {
return true;
}
// Consider the max version if at least two components were given.
unsigned int max_major = 0;
unsigned int max_minor = 0;
unsigned int max_patch = 0;
unsigned int max_tweak = 0;
if (sscanf(version_max.c_str(), "%u.%u.%u.%u", &max_major, &max_minor,
&max_patch, &max_tweak) >= 2) {
unsigned int current_major = cmVersion::GetMajorVersion();
unsigned int current_minor = cmVersion::GetMinorVersion();
unsigned int current_patch = cmVersion::GetPatchVersion();
unsigned int current_tweak = cmVersion::GetTweakVersion();
if ((current_major < max_major) ||
(current_major == max_major && current_minor < max_minor) ||
(current_major == max_major && current_minor == max_minor &&
current_patch < max_patch) ||
(current_major == max_major && current_minor == max_minor &&
current_patch == max_patch && current_tweak < max_tweak)) {
// A ...<max> version was given that is larger than the current
// version of CMake, so tolerate unknown arguments.
return true;
}
}
std::ostringstream e;
e << "called with unknown argument \"" << unknown_arguments[0] << "\".";
status.SetError(e.str());
return false;
}
}
|
