You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1033 lines
38 KiB
1033 lines
38 KiB
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
#include <functional>
|
|
#include <map>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <cm/memory>
|
|
#include <cm/optional>
|
|
#include <cmext/string_view>
|
|
|
|
#include <cm3p/json/reader.h>
|
|
#include <cm3p/json/value.h>
|
|
|
|
#include "cmsys/FStream.hxx"
|
|
|
|
#include "cmCMakePresetsFile.h"
|
|
#include "cmCMakePresetsFileInternal.h"
|
|
#include "cmJSONHelpers.h"
|
|
#include "cmVersion.h"
|
|
|
|
namespace {
|
|
using ReadFileResult = cmCMakePresetsFile::ReadFileResult;
|
|
using CacheVariable = cmCMakePresetsFile::CacheVariable;
|
|
using ConfigurePreset = cmCMakePresetsFile::ConfigurePreset;
|
|
using BuildPreset = cmCMakePresetsFile::BuildPreset;
|
|
using TestPreset = cmCMakePresetsFile::TestPreset;
|
|
using ArchToolsetStrategy = cmCMakePresetsFile::ArchToolsetStrategy;
|
|
|
|
constexpr int MIN_VERSION = 1;
|
|
constexpr int MAX_VERSION = 3;
|
|
|
|
struct CMakeVersion
|
|
{
|
|
unsigned int Major = 0;
|
|
unsigned int Minor = 0;
|
|
unsigned int Patch = 0;
|
|
};
|
|
|
|
struct RootPresets
|
|
{
|
|
CMakeVersion CMakeMinimumRequired;
|
|
std::vector<cmCMakePresetsFile::ConfigurePreset> ConfigurePresets;
|
|
std::vector<cmCMakePresetsFile::BuildPreset> BuildPresets;
|
|
std::vector<cmCMakePresetsFile::TestPreset> TestPresets;
|
|
};
|
|
|
|
std::unique_ptr<cmCMakePresetsFileInternal::NotCondition> InvertCondition(
|
|
std::unique_ptr<cmCMakePresetsFile::Condition> condition)
|
|
{
|
|
auto retval = cm::make_unique<cmCMakePresetsFileInternal::NotCondition>();
|
|
retval->SubCondition = std::move(condition);
|
|
return retval;
|
|
}
|
|
|
|
auto const ConditionStringHelper = cmJSONStringHelper<ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_CONDITION);
|
|
|
|
auto const ConditionBoolHelper = cmJSONBoolHelper<ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_CONDITION);
|
|
|
|
auto const ConditionStringListHelper =
|
|
cmJSONVectorHelper<std::string, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_CONDITION,
|
|
ConditionStringHelper);
|
|
|
|
auto const ConstConditionHelper =
|
|
cmJSONObjectHelper<cmCMakePresetsFileInternal::ConstCondition,
|
|
ReadFileResult>(ReadFileResult::READ_OK,
|
|
ReadFileResult::INVALID_CONDITION, false)
|
|
.Bind<std::string>("type"_s, nullptr, ConditionStringHelper, true)
|
|
.Bind("value"_s, &cmCMakePresetsFileInternal::ConstCondition::Value,
|
|
ConditionBoolHelper, true);
|
|
|
|
auto const EqualsConditionHelper =
|
|
cmJSONObjectHelper<cmCMakePresetsFileInternal::EqualsCondition,
|
|
ReadFileResult>(ReadFileResult::READ_OK,
|
|
ReadFileResult::INVALID_CONDITION, false)
|
|
.Bind<std::string>("type"_s, nullptr, ConditionStringHelper, true)
|
|
.Bind("lhs"_s, &cmCMakePresetsFileInternal::EqualsCondition::Lhs,
|
|
ConditionStringHelper, true)
|
|
.Bind("rhs"_s, &cmCMakePresetsFileInternal::EqualsCondition::Rhs,
|
|
ConditionStringHelper, true);
|
|
|
|
auto const InListConditionHelper =
|
|
cmJSONObjectHelper<cmCMakePresetsFileInternal::InListCondition,
|
|
ReadFileResult>(ReadFileResult::READ_OK,
|
|
ReadFileResult::INVALID_CONDITION, false)
|
|
.Bind<std::string>("type"_s, nullptr, ConditionStringHelper, true)
|
|
.Bind("string"_s, &cmCMakePresetsFileInternal::InListCondition::String,
|
|
ConditionStringHelper, true)
|
|
.Bind("list"_s, &cmCMakePresetsFileInternal::InListCondition::List,
|
|
ConditionStringListHelper, true);
|
|
|
|
auto const MatchesConditionHelper =
|
|
cmJSONObjectHelper<cmCMakePresetsFileInternal::MatchesCondition,
|
|
ReadFileResult>(ReadFileResult::READ_OK,
|
|
ReadFileResult::INVALID_CONDITION, false)
|
|
.Bind<std::string>("type"_s, nullptr, ConditionStringHelper, true)
|
|
.Bind("string"_s, &cmCMakePresetsFileInternal::MatchesCondition::String,
|
|
ConditionStringHelper, true)
|
|
.Bind("regex"_s, &cmCMakePresetsFileInternal::MatchesCondition::Regex,
|
|
ConditionStringHelper, true);
|
|
|
|
ReadFileResult SubConditionHelper(
|
|
std::unique_ptr<cmCMakePresetsFile::Condition>& out,
|
|
const Json::Value* value);
|
|
|
|
auto const ListConditionVectorHelper =
|
|
cmJSONVectorHelper<std::unique_ptr<cmCMakePresetsFile::Condition>,
|
|
ReadFileResult>(ReadFileResult::READ_OK,
|
|
ReadFileResult::INVALID_CONDITION,
|
|
SubConditionHelper);
|
|
auto const AnyAllOfConditionHelper =
|
|
cmJSONObjectHelper<cmCMakePresetsFileInternal::AnyAllOfCondition,
|
|
ReadFileResult>(ReadFileResult::READ_OK,
|
|
ReadFileResult::INVALID_CONDITION, false)
|
|
.Bind<std::string>("type"_s, nullptr, ConditionStringHelper, true)
|
|
.Bind("conditions"_s,
|
|
&cmCMakePresetsFileInternal::AnyAllOfCondition::Conditions,
|
|
ListConditionVectorHelper);
|
|
|
|
auto const NotConditionHelper =
|
|
cmJSONObjectHelper<cmCMakePresetsFileInternal::NotCondition, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_CONDITION, false)
|
|
.Bind<std::string>("type"_s, nullptr, ConditionStringHelper, true)
|
|
.Bind("condition"_s,
|
|
&cmCMakePresetsFileInternal::NotCondition::SubCondition,
|
|
SubConditionHelper);
|
|
|
|
ReadFileResult ConditionHelper(
|
|
std::unique_ptr<cmCMakePresetsFile::Condition>& out,
|
|
const Json::Value* value)
|
|
{
|
|
if (!value) {
|
|
out.reset();
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->isBool()) {
|
|
auto c = cm::make_unique<cmCMakePresetsFileInternal::ConstCondition>();
|
|
c->Value = value->asBool();
|
|
out = std::move(c);
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->isNull()) {
|
|
out = cm::make_unique<cmCMakePresetsFileInternal::NullCondition>();
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->isObject()) {
|
|
if (!value->isMember("type")) {
|
|
return ReadFileResult::INVALID_CONDITION;
|
|
}
|
|
|
|
if (!(*value)["type"].isString()) {
|
|
return ReadFileResult::INVALID_CONDITION;
|
|
}
|
|
auto type = (*value)["type"].asString();
|
|
|
|
if (type == "const") {
|
|
auto c = cm::make_unique<cmCMakePresetsFileInternal::ConstCondition>();
|
|
CHECK_OK(ConstConditionHelper(*c, value));
|
|
out = std::move(c);
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (type == "equals" || type == "notEquals") {
|
|
auto c = cm::make_unique<cmCMakePresetsFileInternal::EqualsCondition>();
|
|
CHECK_OK(EqualsConditionHelper(*c, value));
|
|
out = std::move(c);
|
|
if (type == "notEquals") {
|
|
out = InvertCondition(std::move(out));
|
|
}
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (type == "inList" || type == "notInList") {
|
|
auto c = cm::make_unique<cmCMakePresetsFileInternal::InListCondition>();
|
|
CHECK_OK(InListConditionHelper(*c, value));
|
|
out = std::move(c);
|
|
if (type == "notInList") {
|
|
out = InvertCondition(std::move(out));
|
|
}
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (type == "matches" || type == "notMatches") {
|
|
auto c = cm::make_unique<cmCMakePresetsFileInternal::MatchesCondition>();
|
|
CHECK_OK(MatchesConditionHelper(*c, value));
|
|
out = std::move(c);
|
|
if (type == "notMatches") {
|
|
out = InvertCondition(std::move(out));
|
|
}
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (type == "anyOf" || type == "allOf") {
|
|
auto c =
|
|
cm::make_unique<cmCMakePresetsFileInternal::AnyAllOfCondition>();
|
|
c->StopValue = (type == "anyOf");
|
|
CHECK_OK(AnyAllOfConditionHelper(*c, value));
|
|
out = std::move(c);
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (type == "not") {
|
|
auto c = cm::make_unique<cmCMakePresetsFileInternal::NotCondition>();
|
|
CHECK_OK(NotConditionHelper(*c, value));
|
|
out = std::move(c);
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
}
|
|
|
|
return ReadFileResult::INVALID_CONDITION;
|
|
}
|
|
|
|
ReadFileResult PresetConditionHelper(
|
|
std::shared_ptr<cmCMakePresetsFile::Condition>& out,
|
|
const Json::Value* value)
|
|
{
|
|
std::unique_ptr<cmCMakePresetsFile::Condition> ptr;
|
|
auto result = ConditionHelper(ptr, value);
|
|
out = std::move(ptr);
|
|
return result;
|
|
}
|
|
|
|
ReadFileResult SubConditionHelper(
|
|
std::unique_ptr<cmCMakePresetsFile::Condition>& out,
|
|
const Json::Value* value)
|
|
{
|
|
std::unique_ptr<cmCMakePresetsFile::Condition> ptr;
|
|
auto result = ConditionHelper(ptr, value);
|
|
if (ptr && ptr->IsNull()) {
|
|
return ReadFileResult::INVALID_CONDITION;
|
|
}
|
|
out = std::move(ptr);
|
|
return result;
|
|
}
|
|
|
|
cmJSONHelper<std::nullptr_t, ReadFileResult> VendorHelper(ReadFileResult error)
|
|
{
|
|
return [error](std::nullptr_t& /*out*/,
|
|
const Json::Value* value) -> ReadFileResult {
|
|
if (!value) {
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (!value->isObject()) {
|
|
return error;
|
|
}
|
|
|
|
return ReadFileResult::READ_OK;
|
|
};
|
|
}
|
|
|
|
auto const VersionIntHelper = cmJSONIntHelper<ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_VERSION);
|
|
|
|
auto const VersionHelper = cmJSONRequiredHelper<int, ReadFileResult>(
|
|
ReadFileResult::NO_VERSION, VersionIntHelper);
|
|
|
|
auto const RootVersionHelper =
|
|
cmJSONObjectHelper<int, ReadFileResult>(ReadFileResult::READ_OK,
|
|
ReadFileResult::INVALID_ROOT)
|
|
.Bind("version"_s, VersionHelper, false);
|
|
|
|
auto const VariableStringHelper = cmJSONStringHelper<ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_VARIABLE);
|
|
|
|
ReadFileResult VariableValueHelper(std::string& out, const Json::Value* value)
|
|
{
|
|
if (!value) {
|
|
out.clear();
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->isBool()) {
|
|
out = value->asBool() ? "TRUE" : "FALSE";
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
return VariableStringHelper(out, value);
|
|
}
|
|
|
|
auto const VariableObjectHelper =
|
|
cmJSONObjectHelper<CacheVariable, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_VARIABLE, false)
|
|
.Bind("type"_s, &CacheVariable::Type, VariableStringHelper, false)
|
|
.Bind("value"_s, &CacheVariable::Value, VariableValueHelper);
|
|
|
|
ReadFileResult VariableHelper(cm::optional<CacheVariable>& out,
|
|
const Json::Value* value)
|
|
{
|
|
if (value->isBool()) {
|
|
out = CacheVariable{
|
|
/*Type=*/"BOOL",
|
|
/*Value=*/value->asBool() ? "TRUE" : "FALSE",
|
|
};
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
if (value->isString()) {
|
|
out = CacheVariable{
|
|
/*Type=*/"",
|
|
/*Value=*/value->asString(),
|
|
};
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
if (value->isObject()) {
|
|
out.emplace();
|
|
return VariableObjectHelper(*out, value);
|
|
}
|
|
if (value->isNull()) {
|
|
out = cm::nullopt;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
return ReadFileResult::INVALID_VARIABLE;
|
|
}
|
|
|
|
auto const VariablesHelper =
|
|
cmJSONMapHelper<cm::optional<CacheVariable>, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, VariableHelper);
|
|
|
|
auto const PresetStringHelper = cmJSONStringHelper<ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET);
|
|
|
|
ReadFileResult EnvironmentHelper(cm::optional<std::string>& out,
|
|
const Json::Value* value)
|
|
{
|
|
if (!value || value->isNull()) {
|
|
out = cm::nullopt;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
if (value->isString()) {
|
|
out = value->asString();
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
auto const EnvironmentMapHelper =
|
|
cmJSONMapHelper<cm::optional<std::string>, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET,
|
|
EnvironmentHelper);
|
|
|
|
auto const PresetVectorStringHelper =
|
|
cmJSONVectorHelper<std::string, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET,
|
|
PresetStringHelper);
|
|
|
|
ReadFileResult PresetVectorOneOrMoreStringHelper(std::vector<std::string>& out,
|
|
const Json::Value* value)
|
|
{
|
|
out.clear();
|
|
if (!value) {
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->isString()) {
|
|
out.push_back(value->asString());
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
return PresetVectorStringHelper(out, value);
|
|
}
|
|
|
|
auto const PresetBoolHelper = cmJSONBoolHelper<ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET);
|
|
|
|
auto const PresetOptionalBoolHelper =
|
|
cmJSONOptionalHelper<bool, ReadFileResult>(ReadFileResult::READ_OK,
|
|
PresetBoolHelper);
|
|
|
|
auto const PresetIntHelper = cmJSONIntHelper<ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET);
|
|
|
|
auto const PresetOptionalIntHelper = cmJSONOptionalHelper<int, ReadFileResult>(
|
|
ReadFileResult::READ_OK, PresetIntHelper);
|
|
|
|
auto const PresetVectorIntHelper = cmJSONVectorHelper<int, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, PresetIntHelper);
|
|
|
|
auto const PresetWarningsHelper =
|
|
cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
|
|
.Bind("dev"_s, &ConfigurePreset::WarnDev, PresetOptionalBoolHelper, false)
|
|
.Bind("deprecated"_s, &ConfigurePreset::WarnDeprecated,
|
|
PresetOptionalBoolHelper, false)
|
|
.Bind("uninitialized"_s, &ConfigurePreset::WarnUninitialized,
|
|
PresetOptionalBoolHelper, false)
|
|
.Bind("unusedCli"_s, &ConfigurePreset::WarnUnusedCli,
|
|
PresetOptionalBoolHelper, false)
|
|
.Bind("systemVars"_s, &ConfigurePreset::WarnSystemVars,
|
|
PresetOptionalBoolHelper, false);
|
|
|
|
auto const PresetErrorsHelper =
|
|
cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
|
|
.Bind("dev"_s, &ConfigurePreset::ErrorDev, PresetOptionalBoolHelper, false)
|
|
.Bind("deprecated"_s, &ConfigurePreset::ErrorDeprecated,
|
|
PresetOptionalBoolHelper, false);
|
|
|
|
auto const PresetDebugHelper =
|
|
cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
|
|
.Bind("output"_s, &ConfigurePreset::DebugOutput, PresetOptionalBoolHelper,
|
|
false)
|
|
.Bind("tryCompile"_s, &ConfigurePreset::DebugTryCompile,
|
|
PresetOptionalBoolHelper, false)
|
|
.Bind("find"_s, &ConfigurePreset::DebugFind, PresetOptionalBoolHelper,
|
|
false);
|
|
|
|
ReadFileResult ArchToolsetStrategyHelper(
|
|
cm::optional<ArchToolsetStrategy>& out, const Json::Value* value)
|
|
{
|
|
if (!value) {
|
|
out = cm::nullopt;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (!value->isString()) {
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
if (value->asString() == "set") {
|
|
out = ArchToolsetStrategy::Set;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->asString() == "external") {
|
|
out = ArchToolsetStrategy::External;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
std::function<ReadFileResult(ConfigurePreset&, const Json::Value*)>
|
|
ArchToolsetHelper(
|
|
std::string ConfigurePreset::*valueField,
|
|
cm::optional<ArchToolsetStrategy> ConfigurePreset::*strategyField)
|
|
{
|
|
auto const objectHelper =
|
|
cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
|
|
.Bind("value", valueField, PresetStringHelper, false)
|
|
.Bind("strategy", strategyField, ArchToolsetStrategyHelper, false);
|
|
return [valueField, strategyField, objectHelper](
|
|
ConfigurePreset& out, const Json::Value* value) -> ReadFileResult {
|
|
if (!value) {
|
|
(out.*valueField).clear();
|
|
out.*strategyField = cm::nullopt;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->isString()) {
|
|
out.*valueField = value->asString();
|
|
out.*strategyField = cm::nullopt;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->isObject()) {
|
|
return objectHelper(out, value);
|
|
}
|
|
|
|
return ReadFileResult::INVALID_PRESET;
|
|
};
|
|
}
|
|
|
|
auto const ArchitectureHelper = ArchToolsetHelper(
|
|
&ConfigurePreset::Architecture, &ConfigurePreset::ArchitectureStrategy);
|
|
auto const ToolsetHelper = ArchToolsetHelper(
|
|
&ConfigurePreset::Toolset, &ConfigurePreset::ToolsetStrategy);
|
|
|
|
auto const ConfigurePresetHelper =
|
|
cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
|
|
.Bind("name"_s, &ConfigurePreset::Name, PresetStringHelper)
|
|
.Bind("inherits"_s, &ConfigurePreset::Inherits,
|
|
PresetVectorOneOrMoreStringHelper, false)
|
|
.Bind("hidden"_s, &ConfigurePreset::Hidden, PresetBoolHelper, false)
|
|
.Bind<std::nullptr_t>("vendor"_s, nullptr,
|
|
VendorHelper(ReadFileResult::INVALID_PRESET), false)
|
|
.Bind("displayName"_s, &ConfigurePreset::DisplayName, PresetStringHelper,
|
|
false)
|
|
.Bind("description"_s, &ConfigurePreset::Description, PresetStringHelper,
|
|
false)
|
|
.Bind("generator"_s, &ConfigurePreset::Generator, PresetStringHelper,
|
|
false)
|
|
.Bind("architecture"_s, ArchitectureHelper, false)
|
|
.Bind("toolset"_s, ToolsetHelper, false)
|
|
.Bind("toolchainFile"_s, &ConfigurePreset::ToolchainFile,
|
|
PresetStringHelper, false)
|
|
.Bind("binaryDir"_s, &ConfigurePreset::BinaryDir, PresetStringHelper,
|
|
false)
|
|
.Bind("installDir"_s, &ConfigurePreset::InstallDir, PresetStringHelper,
|
|
false)
|
|
.Bind<std::string>("cmakeExecutable"_s, nullptr, PresetStringHelper, false)
|
|
.Bind("cacheVariables"_s, &ConfigurePreset::CacheVariables,
|
|
VariablesHelper, false)
|
|
.Bind("environment"_s, &ConfigurePreset::Environment, EnvironmentMapHelper,
|
|
false)
|
|
.Bind("warnings"_s, PresetWarningsHelper, false)
|
|
.Bind("errors"_s, PresetErrorsHelper, false)
|
|
.Bind("debug"_s, PresetDebugHelper, false)
|
|
.Bind("condition"_s, &ConfigurePreset::ConditionEvaluator,
|
|
PresetConditionHelper, false);
|
|
|
|
auto const BuildPresetHelper =
|
|
cmJSONObjectHelper<BuildPreset, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
|
|
.Bind("name"_s, &BuildPreset::Name, PresetStringHelper)
|
|
.Bind("inherits"_s, &BuildPreset::Inherits,
|
|
PresetVectorOneOrMoreStringHelper, false)
|
|
.Bind("hidden"_s, &BuildPreset::Hidden, PresetBoolHelper, false)
|
|
.Bind<std::nullptr_t>("vendor"_s, nullptr,
|
|
VendorHelper(ReadFileResult::INVALID_PRESET), false)
|
|
.Bind("displayName"_s, &BuildPreset::DisplayName, PresetStringHelper,
|
|
false)
|
|
.Bind("description"_s, &BuildPreset::Description, PresetStringHelper,
|
|
false)
|
|
.Bind("environment"_s, &BuildPreset::Environment, EnvironmentMapHelper,
|
|
false)
|
|
.Bind("configurePreset"_s, &BuildPreset::ConfigurePreset,
|
|
PresetStringHelper, false)
|
|
.Bind("inheritConfigureEnvironment"_s,
|
|
&BuildPreset::InheritConfigureEnvironment, PresetOptionalBoolHelper,
|
|
false)
|
|
.Bind("jobs"_s, &BuildPreset::Jobs, PresetOptionalIntHelper, false)
|
|
.Bind("targets"_s, &BuildPreset::Targets,
|
|
PresetVectorOneOrMoreStringHelper, false)
|
|
.Bind("configuration"_s, &BuildPreset::Configuration, PresetStringHelper,
|
|
false)
|
|
.Bind("cleanFirst"_s, &BuildPreset::CleanFirst, PresetOptionalBoolHelper,
|
|
false)
|
|
.Bind("verbose"_s, &BuildPreset::Verbose, PresetOptionalBoolHelper, false)
|
|
.Bind("nativeToolOptions"_s, &BuildPreset::NativeToolOptions,
|
|
PresetVectorStringHelper, false)
|
|
.Bind("condition"_s, &BuildPreset::ConditionEvaluator,
|
|
PresetConditionHelper, false);
|
|
|
|
ReadFileResult TestPresetOutputVerbosityHelper(
|
|
TestPreset::OutputOptions::VerbosityEnum& out, const Json::Value* value)
|
|
{
|
|
if (!value) {
|
|
out = TestPreset::OutputOptions::VerbosityEnum::Default;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (!value->isString()) {
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
if (value->asString() == "default") {
|
|
out = TestPreset::OutputOptions::VerbosityEnum::Default;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->asString() == "verbose") {
|
|
out = TestPreset::OutputOptions::VerbosityEnum::Verbose;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->asString() == "extra") {
|
|
out = TestPreset::OutputOptions::VerbosityEnum::Extra;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
auto const TestPresetOptionalOutputVerbosityHelper =
|
|
cmJSONOptionalHelper<TestPreset::OutputOptions::VerbosityEnum,
|
|
ReadFileResult>(ReadFileResult::READ_OK,
|
|
TestPresetOutputVerbosityHelper);
|
|
|
|
auto const TestPresetOptionalOutputHelper =
|
|
cmJSONOptionalHelper<TestPreset::OutputOptions, ReadFileResult>(
|
|
ReadFileResult::READ_OK,
|
|
cmJSONObjectHelper<TestPreset::OutputOptions, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
|
|
.Bind("shortProgress"_s, &TestPreset::OutputOptions::ShortProgress,
|
|
PresetOptionalBoolHelper, false)
|
|
.Bind("verbosity"_s, &TestPreset::OutputOptions::Verbosity,
|
|
TestPresetOptionalOutputVerbosityHelper, false)
|
|
.Bind("debug"_s, &TestPreset::OutputOptions::Debug,
|
|
PresetOptionalBoolHelper, false)
|
|
.Bind("outputOnFailure"_s, &TestPreset::OutputOptions::OutputOnFailure,
|
|
PresetOptionalBoolHelper, false)
|
|
.Bind("quiet"_s, &TestPreset::OutputOptions::Quiet,
|
|
PresetOptionalBoolHelper, false)
|
|
.Bind("outputLogFile"_s, &TestPreset::OutputOptions::OutputLogFile,
|
|
PresetStringHelper, false)
|
|
.Bind("labelSummary"_s, &TestPreset::OutputOptions::LabelSummary,
|
|
PresetOptionalBoolHelper, false)
|
|
.Bind("subprojectSummary"_s,
|
|
&TestPreset::OutputOptions::SubprojectSummary,
|
|
PresetOptionalBoolHelper, false)
|
|
.Bind("maxPassedTestOutputSize"_s,
|
|
&TestPreset::OutputOptions::MaxPassedTestOutputSize,
|
|
PresetOptionalIntHelper, false)
|
|
.Bind("maxFailedTestOutputSize"_s,
|
|
&TestPreset::OutputOptions::MaxFailedTestOutputSize,
|
|
PresetOptionalIntHelper, false)
|
|
.Bind("maxTestNameWidth"_s, &TestPreset::OutputOptions::MaxTestNameWidth,
|
|
PresetOptionalIntHelper, false));
|
|
|
|
auto const TestPresetOptionalFilterIncludeIndexObjectHelper =
|
|
cmJSONOptionalHelper<TestPreset::IncludeOptions::IndexOptions,
|
|
ReadFileResult>(
|
|
ReadFileResult::READ_OK,
|
|
cmJSONObjectHelper<TestPreset::IncludeOptions::IndexOptions,
|
|
ReadFileResult>(ReadFileResult::READ_OK,
|
|
ReadFileResult::INVALID_PRESET)
|
|
.Bind("start"_s, &TestPreset::IncludeOptions::IndexOptions::Start,
|
|
PresetOptionalIntHelper, false)
|
|
.Bind("end"_s, &TestPreset::IncludeOptions::IndexOptions::End,
|
|
PresetOptionalIntHelper, false)
|
|
.Bind("stride"_s, &TestPreset::IncludeOptions::IndexOptions::Stride,
|
|
PresetOptionalIntHelper, false)
|
|
.Bind("specificTests"_s,
|
|
&TestPreset::IncludeOptions::IndexOptions::SpecificTests,
|
|
PresetVectorIntHelper, false));
|
|
|
|
ReadFileResult TestPresetOptionalFilterIncludeIndexHelper(
|
|
cm::optional<TestPreset::IncludeOptions::IndexOptions>& out,
|
|
const Json::Value* value)
|
|
{
|
|
if (!value) {
|
|
out = cm::nullopt;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->isString()) {
|
|
out.emplace();
|
|
out->IndexFile = value->asString();
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->isObject()) {
|
|
return TestPresetOptionalFilterIncludeIndexObjectHelper(out, value);
|
|
}
|
|
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
auto const TestPresetOptionalFilterIncludeHelper =
|
|
cmJSONOptionalHelper<TestPreset::IncludeOptions, ReadFileResult>(
|
|
ReadFileResult::READ_OK,
|
|
cmJSONObjectHelper<TestPreset::IncludeOptions, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET)
|
|
.Bind("name"_s, &TestPreset::IncludeOptions::Name, PresetStringHelper,
|
|
false)
|
|
.Bind("label"_s, &TestPreset::IncludeOptions::Label, PresetStringHelper,
|
|
false)
|
|
.Bind("index"_s, &TestPreset::IncludeOptions::Index,
|
|
TestPresetOptionalFilterIncludeIndexHelper, false)
|
|
.Bind("useUnion"_s, &TestPreset::IncludeOptions::UseUnion,
|
|
PresetOptionalBoolHelper, false));
|
|
|
|
auto const TestPresetOptionalFilterExcludeFixturesHelper =
|
|
cmJSONOptionalHelper<TestPreset::ExcludeOptions::FixturesOptions,
|
|
ReadFileResult>(
|
|
ReadFileResult::READ_OK,
|
|
cmJSONObjectHelper<TestPreset::ExcludeOptions::FixturesOptions,
|
|
ReadFileResult>(ReadFileResult::READ_OK,
|
|
ReadFileResult::INVALID_PRESET)
|
|
.Bind("any"_s, &TestPreset::ExcludeOptions::FixturesOptions::Any,
|
|
PresetStringHelper, false)
|
|
.Bind("setup"_s, &TestPreset::ExcludeOptions::FixturesOptions::Setup,
|
|
PresetStringHelper, false)
|
|
.Bind("cleanup"_s, &TestPreset::ExcludeOptions::FixturesOptions::Cleanup,
|
|
PresetStringHelper, false));
|
|
|
|
auto const TestPresetOptionalFilterExcludeHelper =
|
|
cmJSONOptionalHelper<TestPreset::ExcludeOptions, ReadFileResult>(
|
|
ReadFileResult::READ_OK,
|
|
cmJSONObjectHelper<TestPreset::ExcludeOptions, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET)
|
|
.Bind("name"_s, &TestPreset::ExcludeOptions::Name, PresetStringHelper,
|
|
false)
|
|
.Bind("label"_s, &TestPreset::ExcludeOptions::Label, PresetStringHelper,
|
|
false)
|
|
.Bind("fixtures"_s, &TestPreset::ExcludeOptions::Fixtures,
|
|
TestPresetOptionalFilterExcludeFixturesHelper, false));
|
|
|
|
ReadFileResult TestPresetExecutionShowOnlyHelper(
|
|
TestPreset::ExecutionOptions::ShowOnlyEnum& out, const Json::Value* value)
|
|
{
|
|
if (!value || !value->isString()) {
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
if (value->asString() == "human") {
|
|
out = TestPreset::ExecutionOptions::ShowOnlyEnum::Human;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->asString() == "json-v1") {
|
|
out = TestPreset::ExecutionOptions::ShowOnlyEnum::JsonV1;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
auto const TestPresetOptionalExecutionShowOnlyHelper =
|
|
cmJSONOptionalHelper<TestPreset::ExecutionOptions::ShowOnlyEnum,
|
|
ReadFileResult>(ReadFileResult::READ_OK,
|
|
TestPresetExecutionShowOnlyHelper);
|
|
|
|
ReadFileResult TestPresetExecutionModeHelper(
|
|
TestPreset::ExecutionOptions::RepeatOptions::ModeEnum& out,
|
|
const Json::Value* value)
|
|
{
|
|
if (!value) {
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (!value->isString()) {
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
if (value->asString() == "until-fail") {
|
|
out = TestPreset::ExecutionOptions::RepeatOptions::ModeEnum::UntilFail;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->asString() == "until-pass") {
|
|
out = TestPreset::ExecutionOptions::RepeatOptions::ModeEnum::UntilPass;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->asString() == "after-timeout") {
|
|
out = TestPreset::ExecutionOptions::RepeatOptions::ModeEnum::AfterTimeout;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
auto const TestPresetOptionalExecutionRepeatHelper =
|
|
cmJSONOptionalHelper<TestPreset::ExecutionOptions::RepeatOptions,
|
|
ReadFileResult>(
|
|
ReadFileResult::READ_OK,
|
|
cmJSONObjectHelper<TestPreset::ExecutionOptions::RepeatOptions,
|
|
ReadFileResult>(ReadFileResult::READ_OK,
|
|
ReadFileResult::INVALID_PRESET)
|
|
.Bind("mode"_s, &TestPreset::ExecutionOptions::RepeatOptions::Mode,
|
|
TestPresetExecutionModeHelper, true)
|
|
.Bind("count"_s, &TestPreset::ExecutionOptions::RepeatOptions::Count,
|
|
PresetIntHelper, true));
|
|
|
|
ReadFileResult TestPresetExecutionNoTestsActionHelper(
|
|
TestPreset::ExecutionOptions::NoTestsActionEnum& out,
|
|
const Json::Value* value)
|
|
{
|
|
if (!value) {
|
|
out = TestPreset::ExecutionOptions::NoTestsActionEnum::Default;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (!value->isString()) {
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
if (value->asString() == "default") {
|
|
out = TestPreset::ExecutionOptions::NoTestsActionEnum::Default;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->asString() == "error") {
|
|
out = TestPreset::ExecutionOptions::NoTestsActionEnum::Error;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
if (value->asString() == "ignore") {
|
|
out = TestPreset::ExecutionOptions::NoTestsActionEnum::Ignore;
|
|
return ReadFileResult::READ_OK;
|
|
}
|
|
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
auto const TestPresetOptionalExecutionNoTestsActionHelper =
|
|
cmJSONOptionalHelper<TestPreset::ExecutionOptions::NoTestsActionEnum,
|
|
ReadFileResult>(ReadFileResult::READ_OK,
|
|
TestPresetExecutionNoTestsActionHelper);
|
|
|
|
auto const TestPresetExecutionHelper =
|
|
cmJSONOptionalHelper<TestPreset::ExecutionOptions, ReadFileResult>(
|
|
ReadFileResult::READ_OK,
|
|
cmJSONObjectHelper<TestPreset::ExecutionOptions, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET)
|
|
.Bind("stopOnFailure"_s, &TestPreset::ExecutionOptions::StopOnFailure,
|
|
PresetOptionalBoolHelper, false)
|
|
.Bind("enableFailover"_s, &TestPreset::ExecutionOptions::EnableFailover,
|
|
PresetOptionalBoolHelper, false)
|
|
.Bind("jobs"_s, &TestPreset::ExecutionOptions::Jobs,
|
|
PresetOptionalIntHelper, false)
|
|
.Bind("resourceSpecFile"_s,
|
|
&TestPreset::ExecutionOptions::ResourceSpecFile,
|
|
PresetStringHelper, false)
|
|
.Bind("testLoad"_s, &TestPreset::ExecutionOptions::TestLoad,
|
|
PresetOptionalIntHelper, false)
|
|
.Bind("showOnly"_s, &TestPreset::ExecutionOptions::ShowOnly,
|
|
TestPresetOptionalExecutionShowOnlyHelper, false)
|
|
.Bind("repeat"_s, &TestPreset::ExecutionOptions::Repeat,
|
|
TestPresetOptionalExecutionRepeatHelper, false)
|
|
.Bind("interactiveDebugging"_s,
|
|
&TestPreset::ExecutionOptions::InteractiveDebugging,
|
|
PresetOptionalBoolHelper, false)
|
|
.Bind("scheduleRandom"_s, &TestPreset::ExecutionOptions::ScheduleRandom,
|
|
PresetOptionalBoolHelper, false)
|
|
.Bind("timeout"_s, &TestPreset::ExecutionOptions::Timeout,
|
|
PresetOptionalIntHelper, false)
|
|
.Bind("noTestsAction"_s, &TestPreset::ExecutionOptions::NoTestsAction,
|
|
TestPresetOptionalExecutionNoTestsActionHelper, false));
|
|
|
|
auto const TestPresetFilterHelper =
|
|
cmJSONOptionalHelper<TestPreset::FilterOptions, ReadFileResult>(
|
|
ReadFileResult::READ_OK,
|
|
cmJSONObjectHelper<TestPreset::FilterOptions, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET)
|
|
.Bind("include"_s, &TestPreset::FilterOptions::Include,
|
|
TestPresetOptionalFilterIncludeHelper, false)
|
|
.Bind("exclude"_s, &TestPreset::FilterOptions::Exclude,
|
|
TestPresetOptionalFilterExcludeHelper, false));
|
|
|
|
auto const TestPresetHelper =
|
|
cmJSONObjectHelper<TestPreset, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
|
|
.Bind("name"_s, &TestPreset::Name, PresetStringHelper)
|
|
.Bind("inherits"_s, &TestPreset::Inherits,
|
|
PresetVectorOneOrMoreStringHelper, false)
|
|
.Bind("hidden"_s, &TestPreset::Hidden, PresetBoolHelper, false)
|
|
.Bind<std::nullptr_t>("vendor"_s, nullptr,
|
|
VendorHelper(ReadFileResult::INVALID_PRESET), false)
|
|
.Bind("displayName"_s, &TestPreset::DisplayName, PresetStringHelper, false)
|
|
.Bind("description"_s, &TestPreset::Description, PresetStringHelper, false)
|
|
.Bind("environment"_s, &TestPreset::Environment, EnvironmentMapHelper,
|
|
false)
|
|
.Bind("configurePreset"_s, &TestPreset::ConfigurePreset,
|
|
PresetStringHelper, false)
|
|
.Bind("inheritConfigureEnvironment"_s,
|
|
&TestPreset::InheritConfigureEnvironment, PresetOptionalBoolHelper,
|
|
false)
|
|
.Bind("configuration"_s, &TestPreset::Configuration, PresetStringHelper,
|
|
false)
|
|
.Bind("overwriteConfigurationFile"_s,
|
|
&TestPreset::OverwriteConfigurationFile, PresetVectorStringHelper,
|
|
false)
|
|
.Bind("output"_s, &TestPreset::Output, TestPresetOptionalOutputHelper,
|
|
false)
|
|
.Bind("filter"_s, &TestPreset::Filter, TestPresetFilterHelper, false)
|
|
.Bind("execution"_s, &TestPreset::Execution, TestPresetExecutionHelper,
|
|
false)
|
|
.Bind("condition"_s, &TestPreset::ConditionEvaluator,
|
|
PresetConditionHelper, false);
|
|
|
|
auto const ConfigurePresetsHelper =
|
|
cmJSONVectorHelper<ConfigurePreset, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESETS,
|
|
ConfigurePresetHelper);
|
|
|
|
auto const BuildPresetsHelper =
|
|
cmJSONVectorHelper<BuildPreset, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESETS,
|
|
BuildPresetHelper);
|
|
|
|
auto const TestPresetsHelper = cmJSONVectorHelper<TestPreset, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESETS, TestPresetHelper);
|
|
|
|
auto const CMakeVersionUIntHelper = cmJSONUIntHelper<ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_VERSION);
|
|
|
|
auto const CMakeVersionHelper =
|
|
cmJSONObjectHelper<CMakeVersion, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_CMAKE_VERSION, false)
|
|
.Bind("major"_s, &CMakeVersion::Major, CMakeVersionUIntHelper, false)
|
|
.Bind("minor"_s, &CMakeVersion::Minor, CMakeVersionUIntHelper, false)
|
|
.Bind("patch"_s, &CMakeVersion::Patch, CMakeVersionUIntHelper, false);
|
|
|
|
auto const RootPresetsHelper =
|
|
cmJSONObjectHelper<RootPresets, ReadFileResult>(
|
|
ReadFileResult::READ_OK, ReadFileResult::INVALID_ROOT, false)
|
|
.Bind<int>("version"_s, nullptr, VersionHelper)
|
|
.Bind("configurePresets"_s, &RootPresets::ConfigurePresets,
|
|
ConfigurePresetsHelper, false)
|
|
.Bind("buildPresets"_s, &RootPresets::BuildPresets, BuildPresetsHelper,
|
|
false)
|
|
.Bind("testPresets"_s, &RootPresets::TestPresets, TestPresetsHelper, false)
|
|
.Bind("cmakeMinimumRequired"_s, &RootPresets::CMakeMinimumRequired,
|
|
CMakeVersionHelper, false)
|
|
.Bind<std::nullptr_t>("vendor"_s, nullptr,
|
|
VendorHelper(ReadFileResult::INVALID_ROOT), false);
|
|
}
|
|
|
|
cmCMakePresetsFile::ReadFileResult cmCMakePresetsFile::ReadJSONFile(
|
|
const std::string& filename, bool user)
|
|
{
|
|
cmsys::ifstream fin(filename.c_str());
|
|
if (!fin) {
|
|
return ReadFileResult::FILE_NOT_FOUND;
|
|
}
|
|
// If there's a BOM, toss it.
|
|
cmsys::FStream::ReadBOM(fin);
|
|
|
|
Json::Value root;
|
|
Json::CharReaderBuilder builder;
|
|
Json::CharReaderBuilder::strictMode(&builder.settings_);
|
|
if (!Json::parseFromStream(builder, fin, &root, nullptr)) {
|
|
return ReadFileResult::JSON_PARSE_ERROR;
|
|
}
|
|
|
|
int v = 0;
|
|
auto result = RootVersionHelper(v, &root);
|
|
if (result != ReadFileResult::READ_OK) {
|
|
return result;
|
|
}
|
|
if (v < MIN_VERSION || v > MAX_VERSION) {
|
|
return ReadFileResult::UNRECOGNIZED_VERSION;
|
|
}
|
|
if (user) {
|
|
this->UserVersion = v;
|
|
} else {
|
|
this->Version = v;
|
|
}
|
|
|
|
// Support for build and test presets added in version 2.
|
|
if (v < 2 &&
|
|
(root.isMember("buildPresets") || root.isMember("testPresets"))) {
|
|
return ReadFileResult::BUILD_TEST_PRESETS_UNSUPPORTED;
|
|
}
|
|
|
|
RootPresets presets;
|
|
if ((result = RootPresetsHelper(presets, &root)) !=
|
|
ReadFileResult::READ_OK) {
|
|
return result;
|
|
}
|
|
|
|
unsigned int currentMajor = cmVersion::GetMajorVersion();
|
|
unsigned int currentMinor = cmVersion::GetMinorVersion();
|
|
unsigned int currentPatch = cmVersion::GetPatchVersion();
|
|
auto const& required = presets.CMakeMinimumRequired;
|
|
if (required.Major > currentMajor ||
|
|
(required.Major == currentMajor &&
|
|
(required.Minor > currentMinor ||
|
|
(required.Minor == currentMinor &&
|
|
(required.Patch > currentPatch))))) {
|
|
return ReadFileResult::UNRECOGNIZED_CMAKE_VERSION;
|
|
}
|
|
|
|
for (auto& preset : presets.ConfigurePresets) {
|
|
preset.User = user;
|
|
if (preset.Name.empty()) {
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
PresetPair<ConfigurePreset> presetPair;
|
|
presetPair.Unexpanded = preset;
|
|
presetPair.Expanded = cm::nullopt;
|
|
if (!this->ConfigurePresets
|
|
.emplace(std::make_pair(preset.Name, presetPair))
|
|
.second) {
|
|
return ReadFileResult::DUPLICATE_PRESETS;
|
|
}
|
|
|
|
// Support for installDir presets added in version 3.
|
|
if (v < 3 && !preset.InstallDir.empty()) {
|
|
return ReadFileResult::INSTALL_PREFIX_UNSUPPORTED;
|
|
}
|
|
|
|
// Support for conditions added in version 3.
|
|
if (v < 3 && preset.ConditionEvaluator) {
|
|
return ReadFileResult::CONDITION_UNSUPPORTED;
|
|
}
|
|
|
|
// Support for toolchainFile presets added in version 3.
|
|
if (v < 3 && !preset.ToolchainFile.empty()) {
|
|
return ReadFileResult::TOOLCHAIN_FILE_UNSUPPORTED;
|
|
}
|
|
|
|
this->ConfigurePresetOrder.push_back(preset.Name);
|
|
}
|
|
|
|
for (auto& preset : presets.BuildPresets) {
|
|
preset.User = user;
|
|
if (preset.Name.empty()) {
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
PresetPair<BuildPreset> presetPair;
|
|
presetPair.Unexpanded = preset;
|
|
presetPair.Expanded = cm::nullopt;
|
|
if (!this->BuildPresets.emplace(preset.Name, presetPair).second) {
|
|
return ReadFileResult::DUPLICATE_PRESETS;
|
|
}
|
|
|
|
// Support for conditions added in version 3.
|
|
if (v < 3 && preset.ConditionEvaluator) {
|
|
return ReadFileResult::CONDITION_UNSUPPORTED;
|
|
}
|
|
|
|
this->BuildPresetOrder.push_back(preset.Name);
|
|
}
|
|
|
|
for (auto& preset : presets.TestPresets) {
|
|
preset.User = user;
|
|
if (preset.Name.empty()) {
|
|
return ReadFileResult::INVALID_PRESET;
|
|
}
|
|
|
|
PresetPair<TestPreset> presetPair;
|
|
presetPair.Unexpanded = preset;
|
|
presetPair.Expanded = cm::nullopt;
|
|
if (!this->TestPresets.emplace(preset.Name, presetPair).second) {
|
|
return ReadFileResult::DUPLICATE_PRESETS;
|
|
}
|
|
|
|
// Support for conditions added in version 3.
|
|
if (v < 3 && preset.ConditionEvaluator) {
|
|
return ReadFileResult::CONDITION_UNSUPPORTED;
|
|
}
|
|
|
|
this->TestPresetOrder.push_back(preset.Name);
|
|
}
|
|
|
|
return ReadFileResult::READ_OK;
|
|
}
|