Source/cmCMakePresetsGraphReadJSONConfigurePresets.cxx

   1 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   2    file Copyright.txt or https://cmake.org/licensing for details.  */
   3 #include <cstddef>
   4 #include <functional>
   5 #include <map>
   6 #include <memory>
   7 #include <string>
   8 #include <vector>
   9
  10 #include <cm/optional>
  11 #include <cmext/string_view>
  12
  13 #include <cm3p/json/value.h>
  14
  15 #include "cmCMakePresetsErrors.h"
  16 #include "cmCMakePresetsGraph.h"
  17 #include "cmCMakePresetsGraphInternal.h"
  18 #include "cmJSONHelpers.h"
  19 #include "cmStateTypes.h"
  20
  21 class cmJSONState;
  22
  23 namespace {
  24 using CacheVariable = cmCMakePresetsGraph::CacheVariable;
  25 using ConfigurePreset = cmCMakePresetsGraph::ConfigurePreset;
  26 using ArchToolsetStrategy = cmCMakePresetsGraph::ArchToolsetStrategy;
  27 using JSONHelperBuilder = cmJSONHelperBuilder;
  28 using TraceEnableMode = cmCMakePresetsGraph::TraceEnableMode;
  29 using TraceOutputFormat = cmTraceEnums::TraceOutputFormat;
  30
  31 bool ArchToolsetStrategyHelper(cm::optional<ArchToolsetStrategy>& out,
  32                                const Json::Value* value, cmJSONState* state)
  33 {
  34   if (!value) {
  35     out = cm::nullopt;
  36     return true;
  37   }
  38
  39   if (!value->isString()) {
  40     cmCMakePresetsErrors::INVALID_PRESET(value, state);
  41     return false;
  42   }
  43
  44   if (value->asString() == "set") {
  45     out = ArchToolsetStrategy::Set;
  46     return true;
  47   }
  48
  49   if (value->asString() == "external") {
  50     out = ArchToolsetStrategy::External;
  51     return true;
  52   }
  53
  54   cmCMakePresetsErrors::INVALID_PRESET(value, state);
  55   return false;
  56 }
  57
  58 std::function<bool(ConfigurePreset&, const Json::Value*, cmJSONState*)>
  59 ArchToolsetHelper(
  60   std::string ConfigurePreset::*valueField,
  61   cm::optional<ArchToolsetStrategy> ConfigurePreset::*strategyField)
  62 {
  63   auto const objectHelper =
  64     JSONHelperBuilder::Object<ConfigurePreset>(JsonErrors::INVALID_OBJECT,
  65                                                false)
  66       .Bind("value", valueField,
  67             cmCMakePresetsGraphInternal::PresetStringHelper, false)
  68       .Bind("strategy", strategyField, ArchToolsetStrategyHelper, false);
  69   return [valueField, strategyField,
  70           objectHelper](ConfigurePreset& out, const Json::Value* value,
  71                         cmJSONState* state) -> bool {
  72     if (!value) {
  73       (out.*valueField).clear();
  74       out.*strategyField = cm::nullopt;
  75       return true;
  76     }
  77
  78     if (value->isString()) {
  79       out.*valueField = value->asString();
  80       out.*strategyField = cm::nullopt;
  81       return true;
  82     }
  83
  84     if (value->isObject()) {
  85       return objectHelper(out, value, state);
  86     }
  87
  88     cmCMakePresetsErrors::INVALID_PRESET(value, state);
  89     return false;
  90   };
  91 }
  92
  93 auto const ArchitectureHelper = ArchToolsetHelper(
  94   &ConfigurePreset::Architecture, &ConfigurePreset::ArchitectureStrategy);
  95 auto const ToolsetHelper = ArchToolsetHelper(
  96   &ConfigurePreset::Toolset, &ConfigurePreset::ToolsetStrategy);
  97
  98 bool TraceEnableModeHelper(cm::optional<TraceEnableMode>& out,
  99                            const Json::Value* value, cmJSONState* state)
 100 {
 101   if (!value) {
 102     out = cm::nullopt;
 103     return true;
 104   }
 105
 106   if (!value->isString()) {
 107     cmCMakePresetsErrors::INVALID_PRESET(value, state);
 108     return false;
 109   }
 110
 111   if (value->asString() == "on") {
 112     out = TraceEnableMode::Default;
 113   } else if (value->asString() == "off") {
 114     out = TraceEnableMode::Disable;
 115   } else if (value->asString() == "expand") {
 116     out = TraceEnableMode::Expand;
 117   } else {
 118     cmCMakePresetsErrors::INVALID_PRESET(value, state);
 119     return false;
 120   }
 121
 122   return true;
 123 }
 124
 125 bool TraceOutputFormatHelper(cm::optional<TraceOutputFormat>& out,
 126                              const Json::Value* value, cmJSONState* state)
 127 {
 128   if (!value) {
 129     out = cm::nullopt;
 130     return true;
 131   }
 132
 133   if (!value->isString()) {
 134     cmCMakePresetsErrors::INVALID_PRESET(value, state);
 135     return false;
 136   }
 137
 138   if (value->asString() == "human") {
 139     out = TraceOutputFormat::Human;
 140   } else if (value->asString() == "json-v1") {
 141     out = TraceOutputFormat::JSONv1;
 142   } else {
 143     cmCMakePresetsErrors::INVALID_PRESET(value, state);
 144     return false;
 145   }
 146
 147   return true;
 148 }
 149
 150 auto const VariableStringHelper = JSONHelperBuilder::String();
 151
 152 bool VariableValueHelper(std::string& out, const Json::Value* value,
 153                          cmJSONState* state)
 154 {
 155   if (!value) {
 156     out.clear();
 157     return true;
 158   }
 159
 160   if (value->isBool()) {
 161     out = value->asBool() ? "TRUE" : "FALSE";
 162     return true;
 163   }
 164
 165   return VariableStringHelper(out, value, state);
 166 }
 167
 168 auto const VariableObjectHelper =
 169   JSONHelperBuilder::Object<CacheVariable>(
 170     cmCMakePresetsErrors::INVALID_VARIABLE_OBJECT, false)
 171     .Bind("type"_s, &CacheVariable::Type, VariableStringHelper, false)
 172     .Bind("value"_s, &CacheVariable::Value, VariableValueHelper);
 173
 174 bool VariableHelper(cm::optional<CacheVariable>& out, const Json::Value* value,
 175                     cmJSONState* state)
 176 {
 177   if (value->isBool()) {
 178     out = CacheVariable{
 179       /*Type=*/"BOOL",
 180       /*Value=*/value->asBool() ? "TRUE" : "FALSE",
 181     };
 182     return true;
 183   }
 184   if (value->isString()) {
 185     out = CacheVariable{
 186       /*Type=*/"",
 187       /*Value=*/value->asString(),
 188     };
 189     return true;
 190   }
 191   if (value->isObject()) {
 192     out.emplace();
 193     return VariableObjectHelper(*out, value, state);
 194   }
 195   if (value->isNull()) {
 196     out = cm::nullopt;
 197     return true;
 198   }
 199   cmCMakePresetsErrors::INVALID_VARIABLE(value, state);
 200   return false;
 201 }
 202
 203 auto const VariablesHelper =
 204   JSONHelperBuilder::Map<cm::optional<CacheVariable>>(
 205     cmCMakePresetsErrors::INVALID_PRESET, VariableHelper);
 206
 207 auto const PresetWarningsHelper =
 208   JSONHelperBuilder::Object<ConfigurePreset>(
 209     JsonErrors::INVALID_NAMED_OBJECT_KEY, false)
 210     .Bind("dev"_s, &ConfigurePreset::WarnDev,
 211           cmCMakePresetsGraphInternal::PresetOptionalBoolHelper, false)
 212     .Bind("deprecated"_s, &ConfigurePreset::WarnDeprecated,
 213           cmCMakePresetsGraphInternal::PresetOptionalBoolHelper, false)
 214     .Bind("uninitialized"_s, &ConfigurePreset::WarnUninitialized,
 215           cmCMakePresetsGraphInternal::PresetOptionalBoolHelper, false)
 216     .Bind("unusedCli"_s, &ConfigurePreset::WarnUnusedCli,
 217           cmCMakePresetsGraphInternal::PresetOptionalBoolHelper, false)
 218     .Bind("systemVars"_s, &ConfigurePreset::WarnSystemVars,
 219           cmCMakePresetsGraphInternal::PresetOptionalBoolHelper, false);
 220
 221 auto const PresetErrorsHelper =
 222   JSONHelperBuilder::Object<ConfigurePreset>(
 223     JsonErrors::INVALID_NAMED_OBJECT_KEY, false)
 224     .Bind("dev"_s, &ConfigurePreset::ErrorDev,
 225           cmCMakePresetsGraphInternal::PresetOptionalBoolHelper, false)
 226     .Bind("deprecated"_s, &ConfigurePreset::ErrorDeprecated,
 227           cmCMakePresetsGraphInternal::PresetOptionalBoolHelper, false);
 228
 229 auto const PresetDebugHelper =
 230   JSONHelperBuilder::Object<ConfigurePreset>(
 231     JsonErrors::INVALID_NAMED_OBJECT_KEY, false)
 232     .Bind("output"_s, &ConfigurePreset::DebugOutput,
 233           cmCMakePresetsGraphInternal::PresetOptionalBoolHelper, false)
 234     .Bind("tryCompile"_s, &ConfigurePreset::DebugTryCompile,
 235           cmCMakePresetsGraphInternal::PresetOptionalBoolHelper, false)
 236     .Bind("find"_s, &ConfigurePreset::DebugFind,
 237           cmCMakePresetsGraphInternal::PresetOptionalBoolHelper, false);
 238
 239 auto const PresetTraceHelper =
 240   JSONHelperBuilder::Object<ConfigurePreset>(
 241     cmCMakePresetsErrors::INVALID_PRESET_OBJECT, false)
 242     .Bind("mode"_s, &ConfigurePreset::TraceMode, TraceEnableModeHelper, false)
 243     .Bind("format"_s, &ConfigurePreset::TraceFormat, TraceOutputFormatHelper,
 244           false)
 245     .Bind("source"_s, &ConfigurePreset::TraceSource,
 246           cmCMakePresetsGraphInternal::PresetVectorOneOrMoreStringHelper,
 247           false)
 248     .Bind("redirect"_s, &ConfigurePreset::TraceRedirect,
 249           cmCMakePresetsGraphInternal::PresetStringHelper, false);
 250
 251 auto const ConfigurePresetHelper =
 252   JSONHelperBuilder::Object<ConfigurePreset>(
 253     cmCMakePresetsErrors::INVALID_PRESET_OBJECT, false)
 254     .Bind("name"_s, &ConfigurePreset::Name,
 255           cmCMakePresetsGraphInternal::PresetNameHelper)
 256     .Bind("inherits"_s, &ConfigurePreset::Inherits,
 257           cmCMakePresetsGraphInternal::PresetVectorOneOrMoreStringHelper,
 258           false)
 259     .Bind("hidden"_s, &ConfigurePreset::Hidden,
 260           cmCMakePresetsGraphInternal::PresetBoolHelper, false)
 261     .Bind<std::nullptr_t>("vendor"_s, nullptr,
 262                           cmCMakePresetsGraphInternal::VendorHelper(
 263                             cmCMakePresetsErrors::INVALID_PRESET),
 264                           false)
 265     .Bind("displayName"_s, &ConfigurePreset::DisplayName,
 266           cmCMakePresetsGraphInternal::PresetStringHelper, false)
 267     .Bind("description"_s, &ConfigurePreset::Description,
 268           cmCMakePresetsGraphInternal::PresetStringHelper, false)
 269     .Bind("generator"_s, &ConfigurePreset::Generator,
 270           cmCMakePresetsGraphInternal::PresetStringHelper, false)
 271     .Bind("architecture"_s, ArchitectureHelper, false)
 272     .Bind("toolset"_s, ToolsetHelper, false)
 273     .Bind("toolchainFile"_s, &ConfigurePreset::ToolchainFile,
 274           cmCMakePresetsGraphInternal::PresetStringHelper, false)
 275     .Bind("graphviz"_s, &ConfigurePreset::GraphVizFile,
 276           cmCMakePresetsGraphInternal::PresetStringHelper, false)
 277     .Bind("binaryDir"_s, &ConfigurePreset::BinaryDir,
 278           cmCMakePresetsGraphInternal::PresetStringHelper, false)
 279     .Bind("installDir"_s, &ConfigurePreset::InstallDir,
 280           cmCMakePresetsGraphInternal::PresetStringHelper, false)
 281     .Bind<std::string>("cmakeExecutable"_s, nullptr,
 282                        cmCMakePresetsGraphInternal::PresetStringHelper, false)
 283     .Bind("cacheVariables"_s, &ConfigurePreset::CacheVariables,
 284           VariablesHelper, false)
 285     .Bind("environment"_s, &ConfigurePreset::Environment,
 286           cmCMakePresetsGraphInternal::EnvironmentMapHelper, false)
 287     .Bind("warnings"_s, PresetWarningsHelper, false)
 288     .Bind("errors"_s, PresetErrorsHelper, false)
 289     .Bind("debug"_s, PresetDebugHelper, false)
 290     .Bind("trace"_s, PresetTraceHelper, false)
 291     .Bind("condition"_s, &ConfigurePreset::ConditionEvaluator,
 292           cmCMakePresetsGraphInternal::PresetConditionHelper, false);
 293 }
 294
 295 namespace cmCMakePresetsGraphInternal {
 296 bool ConfigurePresetsHelper(std::vector<ConfigurePreset>& out,
 297                             const Json::Value* value, cmJSONState* state)
 298 {
 299   static auto const helper = JSONHelperBuilder::Vector<ConfigurePreset>(
 300     cmCMakePresetsErrors::INVALID_PRESETS, ConfigurePresetHelper);
 301
 302   return helper(out, value, state);
 303 }
 304 }