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
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
|
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#pragma once
#include "cmConfigure.h" // IWYU pragma: keep
#include <cm3p/json/value.h>
#include "cmJSONHelpers.h"
#include "cmJSONState.h"
#include "cmStringAlgorithms.h"
namespace cmCMakePresetErrors {
const auto getPreset = [](cmJSONState* state) -> const Json::Value* {
if (state->parseStack.size() < 2) {
return nullptr;
}
std::string firstKey = state->parseStack[0].first;
if (firstKey == "configurePresets" || firstKey == "packagePresets" ||
firstKey == "buildPresets" || firstKey == "testPresets") {
return state->parseStack[1].second;
}
return nullptr;
};
const auto getPresetName = [](cmJSONState* state) -> std::string {
#if !defined(CMAKE_BOOTSTRAP)
const Json::Value* preset = getPreset(state);
if (preset != nullptr && preset->isMember("name")) {
return preset->operator[]("name").asString();
}
#endif
return "";
};
const auto getVariableName = [](cmJSONState* state) -> std::string {
std::string var = state->key_after("cacheVariables");
std::string errMsg = cmStrCat("variable \"", var, "\"");
errMsg = cmStrCat(errMsg, " for preset \"", getPresetName(state), "\"");
return errMsg;
};
const auto FILE_NOT_FOUND = [](const std::string& filename,
cmJSONState* state) -> void {
state->AddError(cmStrCat("File not found: ", filename));
};
const auto INVALID_ROOT = [](const Json::Value* value,
cmJSONState* state) -> void {
state->AddErrorAtValue("Invalid root object", value);
};
const auto NO_VERSION = [](const Json::Value* value,
cmJSONState* state) -> void {
state->AddErrorAtValue("No \"version\" field", value);
};
const auto INVALID_VERSION = [](const Json::Value* value,
cmJSONState* state) -> void {
state->AddErrorAtValue("Invalid \"version\" field", value);
};
const auto UNRECOGNIZED_VERSION = [](const Json::Value* value,
cmJSONState* state) -> void {
state->AddErrorAtValue("Unrecognized \"version\" field", value);
};
const auto INVALID_PRESETS = [](const Json::Value* value,
cmJSONState* state) -> void {
state->AddErrorAtValue("Invalid \"configurePresets\" field", value);
};
const auto INVALID_PRESET = [](const Json::Value* value,
cmJSONState* state) -> void {
state->AddErrorAtValue("Invalid preset", value);
};
const auto INVALID_PRESET_NAMED = [](const std::string& presetName,
cmJSONState* state) -> void {
state->AddError(cmStrCat("Invalid preset: \"", presetName, "\""));
};
const auto INVALID_VARIABLE = [](const Json::Value* value,
cmJSONState* state) -> void {
std::string var = cmCMakePresetErrors::getVariableName(state);
state->AddErrorAtValue(cmStrCat("Invalid CMake ", var), value);
};
const auto DUPLICATE_PRESETS = [](const std::string& presetName,
cmJSONState* state) -> void {
state->AddError(cmStrCat("Duplicate preset: \"", presetName, "\""));
};
const auto CYCLIC_PRESET_INHERITANCE = [](const std::string& presetName,
cmJSONState* state) -> void {
state->AddError(
cmStrCat("Cyclic preset inheritance for preset \"", presetName, "\""));
};
const auto INHERITED_PRESET_UNREACHABLE_FROM_FILE =
[](const std::string& presetName, cmJSONState* state) -> void {
state->AddError(cmStrCat("Inherited preset \"", presetName,
"\" is unreachable from preset's file"));
};
const auto CONFIGURE_PRESET_UNREACHABLE_FROM_FILE =
[](const std::string& presetName, cmJSONState* state) -> void {
state->AddError(cmStrCat("Configure preset \"", presetName,
"\" is unreachable from preset's file"));
};
const auto INVALID_MACRO_EXPANSION = [](const std::string& presetName,
cmJSONState* state) -> void {
state->AddError(cmStrCat("Invalid macro expansion in \"", presetName, "\""));
};
const auto BUILD_TEST_PRESETS_UNSUPPORTED = [](const Json::Value*,
cmJSONState* state) -> void {
state->AddError("File version must be 2 or higher for build and test preset "
"support");
};
const auto PACKAGE_PRESETS_UNSUPPORTED = [](const Json::Value*,
cmJSONState* state) -> void {
state->AddError(
"File version must be 6 or higher for package preset support");
};
const auto WORKFLOW_PRESETS_UNSUPPORTED = [](const Json::Value*,
cmJSONState* state) -> void {
state->AddError(
"File version must be 6 or higher for workflow preset support");
};
const auto INCLUDE_UNSUPPORTED = [](const Json::Value*,
cmJSONState* state) -> void {
state->AddError("File version must be 4 or higher for include support");
};
const auto INVALID_INCLUDE = [](const Json::Value* value,
cmJSONState* state) -> void {
state->AddErrorAtValue("Invalid \"include\" field", value);
};
const auto INVALID_CONFIGURE_PRESET = [](const std::string& presetName,
cmJSONState* state) -> void {
state->AddError(
cmStrCat(R"(Invalid "configurePreset": ")", presetName, "\""));
};
const auto INSTALL_PREFIX_UNSUPPORTED = [](const Json::Value* value,
cmJSONState* state) -> void {
state->AddErrorAtValue(
"File version must be 3 or higher for installDir preset "
"support",
value);
};
const auto CONDITION_UNSUPPORTED = [](cmJSONState* state) -> void {
state->AddError("File version must be 3 or higher for condition support");
};
const auto TOOLCHAIN_FILE_UNSUPPORTED = [](cmJSONState* state) -> void {
state->AddError("File version must be 3 or higher for toolchainFile preset "
"support");
};
const auto CYCLIC_INCLUDE = [](const std::string& file,
cmJSONState* state) -> void {
state->AddError(cmStrCat("Cyclic include among preset files: ", file));
};
const auto TEST_OUTPUT_TRUNCATION_UNSUPPORTED =
[](cmJSONState* state) -> void {
state->AddError("File version must be 5 or higher for testOutputTruncation "
"preset support");
};
const auto INVALID_WORKFLOW_STEPS = [](const std::string& workflowStep,
cmJSONState* state) -> void {
state->AddError(cmStrCat("Invalid workflow step \"", workflowStep, "\""));
};
const auto NO_WORKFLOW_STEPS = [](const std::string& presetName,
cmJSONState* state) -> void {
state->AddError(
cmStrCat("No workflow steps specified for \"", presetName, "\""));
};
const auto FIRST_WORKFLOW_STEP_NOT_CONFIGURE = [](const std::string& stepName,
cmJSONState* state) -> void {
state->AddError(cmStrCat("First workflow step \"", stepName,
"\" must be a configure step"));
};
const auto CONFIGURE_WORKFLOW_STEP_NOT_FIRST = [](const std::string& stepName,
cmJSONState* state) -> void {
state->AddError(cmStrCat("Configure workflow step \"", stepName,
"\" must be the first step"));
};
const auto WORKFLOW_STEP_UNREACHABLE_FROM_FILE =
[](const std::string& workflowStep, cmJSONState* state) -> void {
state->AddError(cmStrCat("Workflow step \"", workflowStep,
"\" is unreachable from preset's file"));
};
const auto CTEST_JUNIT_UNSUPPORTED = [](cmJSONState* state) -> void {
state->AddError(
"File version must be 6 or higher for CTest JUnit output support");
};
const auto TRACE_UNSUPPORTED = [](cmJSONState* state) -> void {
state->AddError("File version must be 7 or higher for trace preset support");
};
const auto UNRECOGNIZED_CMAKE_VERSION = [](const std::string& version,
int current, int required) {
return [version, current, required](const Json::Value* value,
cmJSONState* state) -> void {
state->AddErrorAtValue(cmStrCat("\"cmakeMinimumRequired\" ", version,
" version ", required,
" must be less than ", current),
value);
};
};
const auto INVALID_PRESET_NAME = [](const Json::Value* value,
cmJSONState* state) -> void {
std::string errMsg = "Invalid Preset Name";
if (value && value->isConvertibleTo(Json::ValueType::stringValue) &&
!value->asString().empty()) {
errMsg = cmStrCat(errMsg, ": ", value->asString());
}
state->AddErrorAtValue(errMsg, value);
};
const auto INVALID_CONDITION = [](const Json::Value* value,
cmJSONState* state) -> void {
state->AddErrorAtValue(
cmStrCat("Invalid condition for preset \"", getPresetName(state), "\""),
value);
};
const auto INVALID_CONDITION_OBJECT =
[](JsonErrors::ObjectError errorType,
const Json::Value::Members& extraFields) {
return JsonErrors::INVALID_NAMED_OBJECT(
[](const Json::Value*, cmJSONState* state) -> std::string {
return cmStrCat(" condition for preset \"", getPresetName(state),
"\"");
})(errorType, extraFields);
};
const auto INVALID_VARIABLE_OBJECT =
[](JsonErrors::ObjectError errorType,
const Json::Value::Members& extraFields) {
return JsonErrors::INVALID_NAMED_OBJECT(
[](const Json::Value*, cmJSONState* state) -> std::string {
return getVariableName(state);
})(errorType, extraFields);
};
const auto INVALID_PRESET_OBJECT =
[](JsonErrors::ObjectError errorType,
const Json::Value::Members& extraFields) {
return JsonErrors::INVALID_NAMED_OBJECT(
[](const Json::Value*, cmJSONState*) -> std::string {
return "Preset";
})(errorType, extraFields);
};
const auto INVALID_ROOT_OBJECT = [](JsonErrors::ObjectError errorType,
const Json::Value::Members& extraFields) {
return JsonErrors::INVALID_NAMED_OBJECT(
[](const Json::Value*, cmJSONState*) -> std::string {
return "root object";
})(errorType, extraFields);
};
const auto PRESET_MISSING_FIELD = [](const std::string& presetName,
const std::string& missingField,
cmJSONState* state) {
state->AddError(cmStrCat("Preset \"", presetName, "\" missing field \"",
missingField, "\""));
};
}
|
