mirrors/cmake
2
0
Fork 0
mirror of https://gitlab.kitware.com/cmake/cmake.git synced 2026-09-25 04:09:36 +03:00
Code Activity

cmake-presets: Add build and test presets

Browse Source 
Fixes: #21391
This commit is contained in:
Sam Freed
2021-02-01 11:59:40 -05:00
committed by Brad King
parent 4f4f2028b8
commit 676ecf0d37
9 changed files with 1928 additions and 403 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/QtDialog/QCMake.cxx
+7 -6
View File
@@ -68,9 +68,9 @@ QCMake::QCMake(QObject* p)
connect(&this->LoadPresetsTimer, &QTimer::timeout, this, [this]() {
this->loadPresets();
if (!this->PresetName.isEmpty() &&
this->CMakePresetsFile.Presets.find(
this->CMakePresetsFile.ConfigurePresets.find(
std::string(this->PresetName.toLocal8Bit())) ==
this->CMakePresetsFile.Presets.end()) {
this->CMakePresetsFile.ConfigurePresets.end()) {
this->setPreset(QString{});
}
});
@@ -158,7 +158,7 @@ void QCMake::setPreset(const QString& name, bool setBinary)
if (!name.isNull()) {
std::string presetName(name.toLocal8Bit());
auto const& expandedPreset =
this->CMakePresetsFile.Presets[presetName].Expanded;
this->CMakePresetsFile.ConfigurePresets[presetName].Expanded;
if (expandedPreset) {
if (setBinary) {
QString binaryDir =
@@ -420,7 +420,8 @@ QCMakePropertyList QCMake::properties() const
if (!this->PresetName.isNull()) {
std::string presetName(this->PresetName.toLocal8Bit());
auto const& p = this->CMakePresetsFile.Presets.at(presetName).Expanded;
auto const& p =
this->CMakePresetsFile.ConfigurePresets.at(presetName).Expanded;
if (p) {
for (auto const& v : p->CacheVariables) {
if (!v.second) {
@@ -535,8 +536,8 @@ void QCMake::loadPresets()
this->LastLoadPresetsResult = result;
QVector<QCMakePreset> presets;
for (auto const& name : this->CMakePresetsFile.PresetOrder) {
auto const& it = this->CMakePresetsFile.Presets[name];
for (auto const& name : this->CMakePresetsFile.ConfigurePresetOrder) {
auto const& it = this->CMakePresetsFile.ConfigurePresets[name];
auto const& p = it.Unexpanded;
if (p.Hidden) {
continue;
Source/cmCMakePresetsFile.cxx
+1057 -223
View File
@@ -5,6 +5,7 @@
#include <algorithm>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <iterator>
#include <utility>
@@ -20,6 +21,26 @@
#include "cmSystemTools.h"
#include "cmVersion.h"
#define CHECK_OK(expr) \
{ \
auto _result = expr; \
if (_result != ReadFileResult::READ_OK) \
return _result; \
}
#define CHECK_EXPAND(out, field, expanders) \
{ \
switch (ExpandMacros(field, expanders)) { \
case ExpandMacroResult::Error: \
return false; \
case ExpandMacroResult::Ignore: \
out.reset(); \
return true; \
case ExpandMacroResult::Ok: \
break; \
} \
}
namespace {
enum class CycleStatus
{
@@ -30,12 +51,13 @@ enum class CycleStatus
using ReadFileResult = cmCMakePresetsFile::ReadFileResult;
using CacheVariable = cmCMakePresetsFile::CacheVariable;
using UnexpandedPreset = cmCMakePresetsFile::UnexpandedPreset;
using ExpandedPreset = cmCMakePresetsFile::ExpandedPreset;
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 = 1;
constexpr int MAX_VERSION = 2;
struct CMakeVersion
{
@@ -47,7 +69,9 @@ struct CMakeVersion
struct RootPresets
{
CMakeVersion CMakeMinimumRequired;
std::vector<cmCMakePresetsFile::UnexpandedPreset> Presets;
std::vector<cmCMakePresetsFile::ConfigurePreset> ConfigurePresets;
std::vector<cmCMakePresetsFile::BuildPreset> BuildPresets;
std::vector<cmCMakePresetsFile::TestPreset> TestPresets;
};
cmJSONHelper<std::nullptr_t, ReadFileResult> VendorHelper(ReadFileResult error)
@@ -183,35 +207,43 @@ 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<UnexpandedPreset, ReadFileResult>(
cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
.Bind("dev"_s, &UnexpandedPreset::WarnDev, PresetOptionalBoolHelper, false)
.Bind("deprecated"_s, &UnexpandedPreset::WarnDeprecated,
.Bind("dev"_s, &ConfigurePreset::WarnDev, PresetOptionalBoolHelper, false)
.Bind("deprecated"_s, &ConfigurePreset::WarnDeprecated,
PresetOptionalBoolHelper, false)
.Bind("uninitialized"_s, &UnexpandedPreset::WarnUninitialized,
.Bind("uninitialized"_s, &ConfigurePreset::WarnUninitialized,
PresetOptionalBoolHelper, false)
.Bind("unusedCli"_s, &UnexpandedPreset::WarnUnusedCli,
.Bind("unusedCli"_s, &ConfigurePreset::WarnUnusedCli,
PresetOptionalBoolHelper, false)
.Bind("systemVars"_s, &UnexpandedPreset::WarnSystemVars,
.Bind("systemVars"_s, &ConfigurePreset::WarnSystemVars,
PresetOptionalBoolHelper, false);
auto const PresetErrorsHelper =
cmJSONObjectHelper<UnexpandedPreset, ReadFileResult>(
cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
.Bind("dev"_s, &UnexpandedPreset::ErrorDev, PresetOptionalBoolHelper,
false)
.Bind("deprecated"_s, &UnexpandedPreset::ErrorDeprecated,
.Bind("dev"_s, &ConfigurePreset::ErrorDev, PresetOptionalBoolHelper, false)
.Bind("deprecated"_s, &ConfigurePreset::ErrorDeprecated,
PresetOptionalBoolHelper, false);
auto const PresetDebugHelper =
cmJSONObjectHelper<UnexpandedPreset, ReadFileResult>(
cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
.Bind("output"_s, &UnexpandedPreset::DebugOutput, PresetOptionalBoolHelper,
.Bind("output"_s, &ConfigurePreset::DebugOutput, PresetOptionalBoolHelper,
false)
.Bind("tryCompile"_s, &UnexpandedPreset::DebugTryCompile,
.Bind("tryCompile"_s, &ConfigurePreset::DebugTryCompile,
PresetOptionalBoolHelper, false)
.Bind("find"_s, &UnexpandedPreset::DebugFind, PresetOptionalBoolHelper,
.Bind("find"_s, &ConfigurePreset::DebugFind, PresetOptionalBoolHelper,
false);
ReadFileResult ArchToolsetStrategyHelper(
@@ -239,18 +271,18 @@ ReadFileResult ArchToolsetStrategyHelper(
return ReadFileResult::INVALID_PRESET;
}
std::function<ReadFileResult(UnexpandedPreset&, const Json::Value*)>
std::function<ReadFileResult(ConfigurePreset&, const Json::Value*)>
ArchToolsetHelper(
std::string UnexpandedPreset::*valueField,
cm::optional<ArchToolsetStrategy> UnexpandedPreset::*strategyField)
std::string ConfigurePreset::*valueField,
cm::optional<ArchToolsetStrategy> ConfigurePreset::*strategyField)
{
auto const objectHelper =
cmJSONObjectHelper<UnexpandedPreset, ReadFileResult>(
cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
.Bind("value", valueField, PresetStringHelper, false)
.Bind("strategy", strategyField, ArchToolsetStrategyHelper, false);
return [valueField, strategyField, objectHelper](
UnexpandedPreset& out, const Json::Value* value) -> ReadFileResult {
ConfigurePreset& out, const Json::Value* value) -> ReadFileResult {
if (!value) {
(out.*valueField).clear();
out.*strategyField = cm::nullopt;
@@ -272,41 +304,397 @@ ArchToolsetHelper(
}
auto const ArchitectureHelper = ArchToolsetHelper(
&UnexpandedPreset::Architecture, &UnexpandedPreset::ArchitectureStrategy);
&ConfigurePreset::Architecture, &ConfigurePreset::ArchitectureStrategy);
auto const ToolsetHelper = ArchToolsetHelper(
&UnexpandedPreset::Toolset, &UnexpandedPreset::ToolsetStrategy);
&ConfigurePreset::Toolset, &ConfigurePreset::ToolsetStrategy);
auto const PresetHelper =
cmJSONObjectHelper<UnexpandedPreset, ReadFileResult>(
auto const ConfigurePresetHelper =
cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
.Bind("name"_s, &UnexpandedPreset::Name, PresetStringHelper)
.Bind("inherits"_s, &UnexpandedPreset::Inherits, PresetInheritsHelper,
.Bind("name"_s, &ConfigurePreset::Name, PresetStringHelper)
.Bind("inherits"_s, &ConfigurePreset::Inherits, PresetInheritsHelper,
false)
.Bind("hidden"_s, &UnexpandedPreset::Hidden, PresetBoolHelper, false)
.Bind("hidden"_s, &ConfigurePreset::Hidden, PresetBoolHelper, false)
.Bind<std::nullptr_t>("vendor"_s, nullptr,
VendorHelper(ReadFileResult::INVALID_PRESET), false)
.Bind("displayName"_s, &UnexpandedPreset::DisplayName, PresetStringHelper,
.Bind("displayName"_s, &ConfigurePreset::DisplayName, PresetStringHelper,
false)
.Bind("description"_s, &UnexpandedPreset::Description, PresetStringHelper,
.Bind("description"_s, &ConfigurePreset::Description, PresetStringHelper,
false)
.Bind("generator"_s, &UnexpandedPreset::Generator, PresetStringHelper,
.Bind("generator"_s, &ConfigurePreset::Generator, PresetStringHelper,
false)
.Bind("architecture"_s, ArchitectureHelper, false)
.Bind("toolset"_s, ToolsetHelper, false)
.Bind("binaryDir"_s, &UnexpandedPreset::BinaryDir, PresetStringHelper,
.Bind("binaryDir"_s, &ConfigurePreset::BinaryDir, PresetStringHelper,
false)
.Bind<std::string>("cmakeExecutable"_s, nullptr, PresetStringHelper, false)
.Bind("cacheVariables"_s, &UnexpandedPreset::CacheVariables,
.Bind("cacheVariables"_s, &ConfigurePreset::CacheVariables,
VariablesHelper, false)
.Bind("environment"_s, &UnexpandedPreset::Environment,
EnvironmentMapHelper, false)
.Bind("environment"_s, &ConfigurePreset::Environment, EnvironmentMapHelper,
false)
.Bind("warnings"_s, PresetWarningsHelper, false)
.Bind("errors"_s, PresetErrorsHelper, false)
.Bind("debug"_s, PresetDebugHelper, false);
auto const PresetsHelper =
cmJSONVectorHelper<UnexpandedPreset, ReadFileResult>(
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESETS, PresetHelper);
auto const BuildPresetHelper =
cmJSONObjectHelper<BuildPreset, ReadFileResult>(
ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
.Bind("name"_s, &BuildPreset::Name, PresetStringHelper)
.Bind("inherits"_s, &BuildPreset::Inherits, PresetInheritsHelper, 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, PresetVectorStringHelper, 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);
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("rerunFailed"_s, &TestPreset::ExecutionOptions::RerunFailed,
PresetOptionalBoolHelper, 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, PresetInheritsHelper, 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);
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);
@@ -322,7 +710,11 @@ auto const RootPresetsHelper =
cmJSONObjectHelper<RootPresets, ReadFileResult>(
ReadFileResult::READ_OK, ReadFileResult::INVALID_ROOT, false)
.Bind<int>("version"_s, nullptr, VersionHelper)
.Bind("configurePresets"_s, &RootPresets::Presets, PresetsHelper, false)
.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,
@@ -335,23 +727,33 @@ void InheritString(std::string& child, const std::string& parent)
}
}
void InheritOptionalBool(cm::optional<bool>& child,
const cm::optional<bool>& parent)
template <typename T>
void InheritOptionalValue(cm::optional<T>& child,
const cm::optional<T>& parent)
{
if (!child) {
child = parent;
}
}
template <typename T>
void InheritVector(std::vector<T>& child, const std::vector<T>& parent)
{
if (child.empty()) {
child = parent;
}
}
/**
* Check preset inheritance for cycles (using a DAG check algorithm) while
* also bubbling up fields through the inheritance hierarchy, then verify
* that each preset has the required fields, either directly or through
* inheritance.
*/
template <class T>
ReadFileResult VisitPreset(
std::map<std::string, cmCMakePresetsFile::PresetPair>& presets,
UnexpandedPreset& preset, std::map<std::string, CycleStatus> cycleStatus)
T& preset, std::map<std::string, cmCMakePresetsFile::PresetPair<T>>& presets,
std::map<std::string, CycleStatus> cycleStatus)
{
switch (cycleStatus[preset.Name]) {
case CycleStatus::InProgress:
@@ -364,80 +766,44 @@ ReadFileResult VisitPreset(
cycleStatus[preset.Name] = CycleStatus::InProgress;
if (preset.CacheVariables.count("") != 0) {
return ReadFileResult::INVALID_PRESET;
}
if (preset.Environment.count("") != 0) {
return ReadFileResult::INVALID_PRESET;
}
CHECK_OK(preset.VisitPresetBeforeInherit())
for (auto const& i : preset.Inherits) {
auto parent = presets.find(i);
if (parent == presets.end()) {
return ReadFileResult::INVALID_PRESET;
}
if (!preset.User && parent->second.Unexpanded.User) {
auto& parentPreset = parent->second.Unexpanded;
if (!preset.User && parentPreset.User) {
return ReadFileResult::USER_PRESET_INHERITANCE;
}
auto result = VisitPreset(presets, parent->second.Unexpanded, cycleStatus);
auto result = VisitPreset(parentPreset, presets, cycleStatus);
if (result != ReadFileResult::READ_OK) {
return result;
}
InheritString(preset.Generator, parent->second.Unexpanded.Generator);
InheritString(preset.Architecture, parent->second.Unexpanded.Architecture);
InheritString(preset.Toolset, parent->second.Unexpanded.Toolset);
if (!preset.ArchitectureStrategy) {
preset.ArchitectureStrategy =
parent->second.Unexpanded.ArchitectureStrategy;
}
if (!preset.ToolsetStrategy) {
preset.ToolsetStrategy = parent->second.Unexpanded.ToolsetStrategy;
}
InheritString(preset.BinaryDir, parent->second.Unexpanded.BinaryDir);
InheritOptionalBool(preset.WarnDev, parent->second.Unexpanded.WarnDev);
InheritOptionalBool(preset.ErrorDev, parent->second.Unexpanded.ErrorDev);
InheritOptionalBool(preset.WarnDeprecated,
parent->second.Unexpanded.WarnDeprecated);
InheritOptionalBool(preset.ErrorDeprecated,
parent->second.Unexpanded.ErrorDeprecated);
InheritOptionalBool(preset.WarnUninitialized,
parent->second.Unexpanded.WarnUninitialized);
InheritOptionalBool(preset.WarnUnusedCli,
parent->second.Unexpanded.WarnUnusedCli);
InheritOptionalBool(preset.WarnSystemVars,
parent->second.Unexpanded.WarnSystemVars);
for (auto const& v : parent->second.Unexpanded.CacheVariables) {
preset.CacheVariables.insert(v);
}
for (auto const& v : parent->second.Unexpanded.Environment) {
CHECK_OK(preset.VisitPresetInherit(parentPreset))
for (auto const& v : parentPreset.Environment) {
preset.Environment.insert(v);
}
}
if (!preset.Hidden) {
if (preset.Generator.empty()) {
return ReadFileResult::INVALID_PRESET;
}
if (preset.BinaryDir.empty()) {
return ReadFileResult::INVALID_PRESET;
}
if (preset.WarnDev == false && preset.ErrorDev == true) {
return ReadFileResult::INVALID_PRESET;
}
if (preset.WarnDeprecated == false && preset.ErrorDeprecated == true) {
return ReadFileResult::INVALID_PRESET;
}
}
CHECK_OK(preset.VisitPresetAfterInherit())
cycleStatus[preset.Name] = CycleStatus::Verified;
return ReadFileResult::READ_OK;
}
template <class T>
ReadFileResult ComputePresetInheritance(
std::map<std::string, cmCMakePresetsFile::PresetPair>& presets)
std::map<std::string, cmCMakePresetsFile::PresetPair<T>>& presets)
{
std::map<std::string, CycleStatus> cycleStatus;
for (auto const& it : presets) {
@@ -445,7 +811,7 @@ ReadFileResult ComputePresetInheritance(
}
for (auto& it : presets) {
auto result = VisitPreset(presets, it.second.Unexpanded, cycleStatus);
auto result = VisitPreset<T>(it.second.Unexpanded, presets, cycleStatus);
if (result != ReadFileResult::READ_OK) {
return result;
}
@@ -482,56 +848,26 @@ enum class ExpandMacroResult
Error,
};
ExpandMacroResult VisitEnv(const cmCMakePresetsFile& file,
cmCMakePresetsFile::ExpandedPreset& preset,
std::map<std::string, CycleStatus>& envCycles,
std::string& value, CycleStatus& status);
ExpandMacroResult ExpandMacros(const cmCMakePresetsFile& file,
cmCMakePresetsFile::ExpandedPreset& preset,
std::map<std::string, CycleStatus>& envCycles,
std::string& out);
ExpandMacroResult ExpandMacro(const cmCMakePresetsFile& file,
cmCMakePresetsFile::ExpandedPreset& preset,
std::map<std::string, CycleStatus>& envCycles,
std::string& out,
const std::string& macroNamespace,
const std::string& macroName);
using MacroExpander = std::function<ExpandMacroResult(
const std::string&, const std::string&, std::string&)>;
ExpandMacroResult VisitEnv(std::string& value, CycleStatus& status,
const std::vector<MacroExpander>& macroExpanders);
ExpandMacroResult ExpandMacros(
std::string& out, const std::vector<MacroExpander>& macroExpanders);
ExpandMacroResult ExpandMacro(
std::string& out, const std::string& macroNamespace,
const std::string& macroName,
const std::vector<MacroExpander>& macroExpanders);
bool ExpandMacros(const cmCMakePresetsFile& file,
const UnexpandedPreset& preset,
cm::optional<ExpandedPreset>& out)
const ConfigurePreset& preset,
cm::optional<ConfigurePreset>& out,
const std::vector<MacroExpander>& macroExpanders)
{
out = preset;
std::map<std::string, CycleStatus> envCycles;
for (auto const& v : out->Environment) {
envCycles[v.first] = CycleStatus::Unvisited;
}
for (auto& v : out->Environment) {
if (v.second) {
switch (VisitEnv(file, *out, envCycles, *v.second, envCycles[v.first])) {
case ExpandMacroResult::Error:
return false;
case ExpandMacroResult::Ignore:
out.reset();
return true;
case ExpandMacroResult::Ok:
break;
}
}
}
std::string binaryDir = preset.BinaryDir;
switch (ExpandMacros(file, *out, envCycles, binaryDir)) {
case ExpandMacroResult::Error:
return false;
case ExpandMacroResult::Ignore:
out.reset();
return true;
case ExpandMacroResult::Ok:
break;
}
CHECK_EXPAND(out, binaryDir, macroExpanders)
if (!cmSystemTools::FileIsFullPath(binaryDir)) {
binaryDir = cmStrCat(file.SourceDir, '/', binaryDir);
}
@@ -540,7 +876,158 @@ bool ExpandMacros(const cmCMakePresetsFile& file,
for (auto& variable : out->CacheVariables) {
if (variable.second) {
switch (ExpandMacros(file, *out, envCycles, variable.second->Value)) {
CHECK_EXPAND(out, variable.second->Value, macroExpanders)
}
}
return true;
}
bool ExpandMacros(const cmCMakePresetsFile&, const BuildPreset&,
cm::optional<BuildPreset>& out,
const std::vector<MacroExpander>& macroExpanders)
{
for (auto& target : out->Targets) {
CHECK_EXPAND(out, target, macroExpanders)
}
for (auto& nativeToolOption : out->NativeToolOptions) {
CHECK_EXPAND(out, nativeToolOption, macroExpanders)
}
return true;
}
bool ExpandMacros(const cmCMakePresetsFile&, const TestPreset&,
cm::optional<TestPreset>& out,
const std::vector<MacroExpander>& macroExpanders)
{
for (auto& overwrite : out->OverwriteConfigurationFile) {
CHECK_EXPAND(out, overwrite, macroExpanders);
}
if (out->Output) {
CHECK_EXPAND(out, out->Output->OutputLogFile, macroExpanders)
}
if (out->Filter) {
if (out->Filter->Include) {
CHECK_EXPAND(out, out->Filter->Include->Name, macroExpanders)
CHECK_EXPAND(out, out->Filter->Include->Label, macroExpanders)
if (out->Filter->Include->Index) {
CHECK_EXPAND(out, out->Filter->Include->Index->IndexFile,
macroExpanders);
}
}
if (out->Filter->Exclude) {
CHECK_EXPAND(out, out->Filter->Exclude->Name, macroExpanders)
CHECK_EXPAND(out, out->Filter->Exclude->Label, macroExpanders)
if (out->Filter->Exclude->Fixtures) {
CHECK_EXPAND(out, out->Filter->Exclude->Fixtures->Any, macroExpanders)
CHECK_EXPAND(out, out->Filter->Exclude->Fixtures->Setup,
macroExpanders)
CHECK_EXPAND(out, out->Filter->Exclude->Fixtures->Cleanup,
macroExpanders)
}
}
}
if (out->Execution) {
CHECK_EXPAND(out, out->Execution->ResourceSpecFile, macroExpanders)
}
return true;
}
template <class T>
bool ExpandMacros(const cmCMakePresetsFile& file, const T& preset,
cm::optional<T>& out)
{
out.emplace(preset);
std::map<std::string, CycleStatus> envCycles;
for (auto const& v : out->Environment) {
envCycles[v.first] = CycleStatus::Unvisited;
}
std::vector<MacroExpander> macroExpanders;
MacroExpander defaultMacroExpander =
[&file, &preset](const std::string& macroNamespace,
const std::string& macroName,
std::string& macroOut) -> ExpandMacroResult {
if (macroNamespace.empty()) {
if (macroName == "sourceDir") {
macroOut += file.SourceDir;
return ExpandMacroResult::Ok;
}
if (macroName == "sourceParentDir") {
macroOut += cmSystemTools::GetParentDirectory(file.SourceDir);
return ExpandMacroResult::Ok;
}
if (macroName == "sourceDirName") {
macroOut += cmSystemTools::GetFilenameName(file.SourceDir);
return ExpandMacroResult::Ok;
}
if (macroName == "presetName") {
macroOut += preset.Name;
return ExpandMacroResult::Ok;
}
if (macroName == "generator") {
// Generator only makes sense if preset is not hidden.
if (!preset.Hidden) {
macroOut += file.GetGeneratorForPreset(preset.Name);
}
return ExpandMacroResult::Ok;
}
if (macroName == "dollar") {
macroOut += '$';
return ExpandMacroResult::Ok;
}
}
return ExpandMacroResult::Ignore;
};
MacroExpander environmentMacroExpander =
[&macroExpanders, &out, &envCycles](
const std::string& macroNamespace, const std::string& macroName,
std::string& result) -> ExpandMacroResult {
if (macroNamespace == "env" && !macroName.empty() && out) {
auto v = out->Environment.find(macroName);
if (v != out->Environment.end() && v->second) {
auto e = VisitEnv(*v->second, envCycles[macroName], macroExpanders);
if (e != ExpandMacroResult::Ok) {
return e;
}
result += *v->second;
return ExpandMacroResult::Ok;
}
}
if (macroNamespace == "env" || macroNamespace == "penv") {
if (macroName.empty()) {
return ExpandMacroResult::Error;
}
const char* value = std::getenv(macroName.c_str());
if (value) {
result += value;
}
return ExpandMacroResult::Ok;
}
return ExpandMacroResult::Ignore;
};
macroExpanders.push_back(defaultMacroExpander);
macroExpanders.push_back(environmentMacroExpander);
for (auto& v : out->Environment) {
if (v.second) {
switch (VisitEnv(*v.second, envCycles[v.first], macroExpanders)) {
case ExpandMacroResult::Error:
return false;
case ExpandMacroResult::Ignore:
@@ -552,13 +1039,11 @@ bool ExpandMacros(const cmCMakePresetsFile& file,
}
}
return true;
return ExpandMacros(file, preset, out, macroExpanders);
}
ExpandMacroResult VisitEnv(const cmCMakePresetsFile& file,
cmCMakePresetsFile::ExpandedPreset& preset,
std::map<std::string, CycleStatus>& envCycles,
std::string& value, CycleStatus& status)
ExpandMacroResult VisitEnv(std::string& value, CycleStatus& status,
const std::vector<MacroExpander>& macroExpanders)
{
if (status == CycleStatus::Verified) {
return ExpandMacroResult::Ok;
@@ -568,7 +1053,7 @@ ExpandMacroResult VisitEnv(const cmCMakePresetsFile& file,
}
status = CycleStatus::InProgress;
auto e = ExpandMacros(file, preset, envCycles, value);
auto e = ExpandMacros(value, macroExpanders);
if (e != ExpandMacroResult::Ok) {
return e;
}
@@ -576,10 +1061,8 @@ ExpandMacroResult VisitEnv(const cmCMakePresetsFile& file,
return ExpandMacroResult::Ok;
}
ExpandMacroResult ExpandMacros(const cmCMakePresetsFile& file,
cmCMakePresetsFile::ExpandedPreset& preset,
std::map<std::string, CycleStatus>& envCycles,
std::string& out)
ExpandMacroResult ExpandMacros(
std::string& out, const std::vector<MacroExpander>& macroExpanders)
{
std::string result;
std::string macroNamespace;
@@ -626,8 +1109,8 @@ ExpandMacroResult ExpandMacros(const cmCMakePresetsFile& file,
case State::MacroName:
if (c == '}') {
auto e = ExpandMacro(file, preset, envCycles, result, macroNamespace,
macroName);
auto e =
ExpandMacro(result, macroNamespace, macroName, macroExpanders);
if (e != ExpandMacroResult::Ok) {
return e;
}
@@ -656,62 +1139,16 @@ ExpandMacroResult ExpandMacros(const cmCMakePresetsFile& file,
return ExpandMacroResult::Ok;
}
ExpandMacroResult ExpandMacro(const cmCMakePresetsFile& file,
cmCMakePresetsFile::ExpandedPreset& preset,
std::map<std::string, CycleStatus>& envCycles,
std::string& out,
ExpandMacroResult ExpandMacro(std::string& out,
const std::string& macroNamespace,
const std::string& macroName)
const std::string& macroName,
const std::vector<MacroExpander>& macroExpanders)
{
if (macroNamespace.empty()) {
if (macroName == "sourceDir") {
out += file.SourceDir;
return ExpandMacroResult::Ok;
for (auto const& macroExpander : macroExpanders) {
auto result = macroExpander(macroNamespace, macroName, out);
if (result != ExpandMacroResult::Ignore) {
return result;
}
if (macroName == "sourceParentDir") {
out += cmSystemTools::GetParentDirectory(file.SourceDir);
return ExpandMacroResult::Ok;
}
if (macroName == "sourceDirName") {
out += cmSystemTools::GetFilenameName(file.SourceDir);
return ExpandMacroResult::Ok;
}
if (macroName == "presetName") {
out += preset.Name;
return ExpandMacroResult::Ok;
}
if (macroName == "generator") {
out += preset.Generator;
return ExpandMacroResult::Ok;
}
if (macroName == "dollar") {
out += '$';
return ExpandMacroResult::Ok;
}
}
if (macroNamespace == "env" && !macroName.empty()) {
auto v = preset.Environment.find(macroName);
if (v != preset.Environment.end() && v->second) {
auto e =
VisitEnv(file, preset, envCycles, *v->second, envCycles[macroName]);
if (e != ExpandMacroResult::Ok) {
return e;
}
out += *v->second;
return ExpandMacroResult::Ok;
}
}
if (macroNamespace == "env" || macroNamespace == "penv") {
if (macroName.empty()) {
return ExpandMacroResult::Error;
}
const char* value = std::getenv(macroName.c_str());
if (value) {
out += value;
}
return ExpandMacroResult::Ok;
}
if (macroNamespace == "vendor") {
@@ -722,6 +1159,214 @@ ExpandMacroResult ExpandMacro(const cmCMakePresetsFile& file,
}
}
cmCMakePresetsFile::ReadFileResult
cmCMakePresetsFile::ConfigurePreset::VisitPresetInherit(
const cmCMakePresetsFile::Preset& parentPreset)
{
auto& preset = *this;
const ConfigurePreset& parent =
static_cast<const ConfigurePreset&>(parentPreset);
InheritString(preset.Generator, parent.Generator);
InheritString(preset.Architecture, parent.Architecture);
InheritString(preset.Toolset, parent.Toolset);
if (!preset.ArchitectureStrategy) {
preset.ArchitectureStrategy = parent.ArchitectureStrategy;
}
if (!preset.ToolsetStrategy) {
preset.ToolsetStrategy = parent.ToolsetStrategy;
}
InheritString(preset.BinaryDir, parent.BinaryDir);
InheritOptionalValue(preset.WarnDev, parent.WarnDev);
InheritOptionalValue(preset.ErrorDev, parent.ErrorDev);
InheritOptionalValue(preset.WarnDeprecated, parent.WarnDeprecated);
InheritOptionalValue(preset.ErrorDeprecated, parent.ErrorDeprecated);
InheritOptionalValue(preset.WarnUninitialized, parent.WarnUninitialized);
InheritOptionalValue(preset.WarnUnusedCli, parent.WarnUnusedCli);
InheritOptionalValue(preset.WarnSystemVars, parent.WarnSystemVars);
for (auto const& v : parent.CacheVariables) {
preset.CacheVariables.insert(v);
}
return ReadFileResult::READ_OK;
}
cmCMakePresetsFile::ReadFileResult
cmCMakePresetsFile::ConfigurePreset::VisitPresetBeforeInherit()
{
auto& preset = *this;
if (preset.Environment.count("") != 0) {
return ReadFileResult::INVALID_PRESET;
}
return ReadFileResult::READ_OK;
}
cmCMakePresetsFile::ReadFileResult
cmCMakePresetsFile::ConfigurePreset::VisitPresetAfterInherit()
{
auto& preset = *this;
if (!preset.Hidden) {
if (preset.Generator.empty()) {
return ReadFileResult::INVALID_PRESET;
}
if (preset.BinaryDir.empty()) {
return ReadFileResult::INVALID_PRESET;
}
if (preset.WarnDev == false && preset.ErrorDev == true) {
return ReadFileResult::INVALID_PRESET;
}
if (preset.WarnDeprecated == false && preset.ErrorDeprecated == true) {
return ReadFileResult::INVALID_PRESET;
}
if (preset.CacheVariables.count("") != 0) {
return ReadFileResult::INVALID_PRESET;
}
}
return ReadFileResult::READ_OK;
}
cmCMakePresetsFile::ReadFileResult
cmCMakePresetsFile::BuildPreset::VisitPresetInherit(
const cmCMakePresetsFile::Preset& parentPreset)
{
auto& preset = *this;
const BuildPreset& parent = static_cast<const BuildPreset&>(parentPreset);
InheritString(preset.ConfigurePreset, parent.ConfigurePreset);
InheritOptionalValue(preset.InheritConfigureEnvironment,
parent.InheritConfigureEnvironment);
InheritOptionalValue(preset.Jobs, parent.Jobs);
InheritVector(preset.Targets, parent.Targets);
InheritString(preset.Configuration, parent.Configuration);
InheritOptionalValue(preset.CleanFirst, parent.CleanFirst);
InheritOptionalValue(preset.Verbose, parent.Verbose);
InheritVector(preset.NativeToolOptions, parent.NativeToolOptions);
return ReadFileResult::READ_OK;
}
cmCMakePresetsFile::ReadFileResult
cmCMakePresetsFile::BuildPreset::VisitPresetAfterInherit()
{
auto& preset = *this;
if (!preset.Hidden && preset.ConfigurePreset.empty()) {
return ReadFileResult::INVALID_PRESET;
}
return ReadFileResult::READ_OK;
}
cmCMakePresetsFile::ReadFileResult
cmCMakePresetsFile::TestPreset::VisitPresetInherit(
const cmCMakePresetsFile::Preset& parentPreset)
{
auto& preset = *this;
const TestPreset& parent = static_cast<const TestPreset&>(parentPreset);
InheritString(preset.ConfigurePreset, parent.ConfigurePreset);
InheritOptionalValue(preset.InheritConfigureEnvironment,
parent.InheritConfigureEnvironment);
InheritString(preset.Configuration, parent.Configuration);
InheritVector(preset.OverwriteConfigurationFile,
parent.OverwriteConfigurationFile);
if (parent.Output) {
if (preset.Output) {
auto& output = preset.Output.value();
const auto& parentOutput = parent.Output.value();
InheritOptionalValue(output.ShortProgress, parentOutput.ShortProgress);
InheritOptionalValue(output.Verbosity, parentOutput.Verbosity);
InheritOptionalValue(output.Debug, parentOutput.Debug);
InheritOptionalValue(output.OutputOnFailure,
parentOutput.OutputOnFailure);
InheritString(output.OutputLogFile, parentOutput.OutputLogFile);
InheritOptionalValue(output.LabelSummary, parentOutput.LabelSummary);
InheritOptionalValue(output.SubprojectSummary,
parentOutput.SubprojectSummary);
InheritOptionalValue(output.MaxPassedTestOutputSize,
parentOutput.MaxPassedTestOutputSize);
InheritOptionalValue(output.MaxFailedTestOutputSize,
parentOutput.MaxFailedTestOutputSize);
InheritOptionalValue(output.MaxTestNameWidth,
parentOutput.MaxTestNameWidth);
} else {
preset.Output = parent.Output;
}
}
if (parent.Filter) {
if (parent.Filter->Include) {
if (preset.Filter && preset.Filter->Include) {
auto& include = *preset.Filter->Include;
const auto& parentInclude = *parent.Filter->Include;
InheritString(include.Name, parentInclude.Name);
InheritString(include.Label, parentInclude.Label);
InheritOptionalValue(include.Index, parentInclude.Index);
} else {
if (!preset.Filter) {
preset.Filter.emplace();
}
preset.Filter->Include = parent.Filter->Include;
}
}
if (parent.Filter->Exclude) {
if (preset.Filter && preset.Filter->Exclude) {
auto& exclude = *preset.Filter->Exclude;
const auto& parentExclude = *parent.Filter->Exclude;
InheritString(exclude.Name, parentExclude.Name);
InheritString(exclude.Label, parentExclude.Label);
InheritOptionalValue(exclude.Fixtures, parentExclude.Fixtures);
} else {
if (!preset.Filter) {
preset.Filter.emplace();
}
preset.Filter->Exclude = parent.Filter->Exclude;
}
}
}
if (parent.Execution) {
if (preset.Execution) {
auto& execution = *preset.Execution;
const auto& parentExecution = *parent.Execution;
InheritOptionalValue(execution.StopOnFailure,
parentExecution.StopOnFailure);
InheritOptionalValue(execution.EnableFailover,
parentExecution.EnableFailover);
InheritOptionalValue(execution.Jobs, parentExecution.Jobs);
InheritString(execution.ResourceSpecFile,
parentExecution.ResourceSpecFile);
InheritOptionalValue(execution.TestLoad, parentExecution.TestLoad);
InheritOptionalValue(execution.ShowOnly, parentExecution.ShowOnly);
InheritOptionalValue(execution.RerunFailed, parentExecution.RerunFailed);
InheritOptionalValue(execution.Repeat, parentExecution.Repeat);
InheritOptionalValue(execution.InteractiveDebugging,
parentExecution.InteractiveDebugging);
InheritOptionalValue(execution.ScheduleRandom,
parentExecution.ScheduleRandom);
InheritOptionalValue(execution.Timeout, parentExecution.Timeout);
InheritOptionalValue(execution.NoTestsAction,
parentExecution.NoTestsAction);
} else {
preset.Execution = parent.Execution;
}
}
return ReadFileResult::READ_OK;
}
cmCMakePresetsFile::ReadFileResult
cmCMakePresetsFile::TestPreset::VisitPresetAfterInherit()
{
auto& preset = *this;
if (!preset.Hidden && preset.ConfigurePreset.empty()) {
return ReadFileResult::INVALID_PRESET;
}
return ReadFileResult::READ_OK;
}
std::string cmCMakePresetsFile::GetFilename(const std::string& sourceDir)
{
return cmStrCat(sourceDir, "/CMakePresets.json");
@@ -735,17 +1380,25 @@ std::string cmCMakePresetsFile::GetUserFilename(const std::string& sourceDir)
cmCMakePresetsFile::ReadFileResult cmCMakePresetsFile::ReadProjectPresets(
const std::string& sourceDir, bool allowNoFiles)
{
bool haveOneFile = false;
this->SourceDir = sourceDir;
this->Presets.clear();
this->PresetOrder.clear();
this->ClearPresets();
std::vector<std::string> presetOrder;
std::map<std::string, PresetPair> presetMap;
auto result = this->ReadProjectPresetsInternal(allowNoFiles);
if (result != ReadFileResult::READ_OK) {
this->ClearPresets();
}
return result;
}
cmCMakePresetsFile::ReadFileResult
cmCMakePresetsFile::ReadProjectPresetsInternal(bool allowNoFiles)
{
bool haveOneFile = false;
std::string filename = GetUserFilename(this->SourceDir);
if (cmSystemTools::FileExists(filename)) {
auto result = this->ReadJSONFile(filename, presetOrder, presetMap, true);
auto result = this->ReadJSONFile(filename, true);
if (result != ReadFileResult::READ_OK) {
return result;
}
@@ -754,7 +1407,7 @@ cmCMakePresetsFile::ReadFileResult cmCMakePresetsFile::ReadProjectPresets(
filename = GetFilename(this->SourceDir);
if (cmSystemTools::FileExists(filename)) {
auto result = this->ReadJSONFile(filename, presetOrder, presetMap, false);
auto result = this->ReadJSONFile(filename, false);
if (result != ReadFileResult::READ_OK) {
return result;
}
@@ -766,19 +1419,50 @@ cmCMakePresetsFile::ReadFileResult cmCMakePresetsFile::ReadProjectPresets(
: ReadFileResult::FILE_NOT_FOUND;
}
auto result = ComputePresetInheritance(presetMap);
if (result != ReadFileResult::READ_OK) {
return result;
CHECK_OK(ComputePresetInheritance(this->ConfigurePresets))
CHECK_OK(ComputePresetInheritance(this->BuildPresets))
CHECK_OK(ComputePresetInheritance(this->TestPresets))
for (auto& it : this->ConfigurePresets) {
if (!ExpandMacros(*this, it.second.Unexpanded, it.second.Expanded)) {
return ReadFileResult::INVALID_MACRO_EXPANSION;
}
}
for (auto& it : this->BuildPresets) {
if (!it.second.Unexpanded.Hidden) {
const auto configurePreset =
this->ConfigurePresets.find(it.second.Unexpanded.ConfigurePreset);
if (it.second.Unexpanded.InheritConfigureEnvironment.value_or(true) &&
configurePreset != this->ConfigurePresets.end()) {
it.second.Unexpanded.Environment.insert(
configurePreset->second.Unexpanded.Environment.begin(),
configurePreset->second.Unexpanded.Environment.end());
}
}
if (!ExpandMacros(*this, it.second.Unexpanded, it.second.Expanded)) {
return ReadFileResult::INVALID_MACRO_EXPANSION;
}
}
for (auto& it : this->TestPresets) {
if (!it.second.Unexpanded.Hidden) {
const auto configurePreset =
this->ConfigurePresets.find(it.second.Unexpanded.ConfigurePreset);
if (it.second.Unexpanded.InheritConfigureEnvironment.value_or(true) &&
configurePreset != this->ConfigurePresets.end()) {
it.second.Unexpanded.Environment.insert(
configurePreset->second.Unexpanded.Environment.begin(),
configurePreset->second.Unexpanded.Environment.end());
}
}
for (auto& it : presetMap) {
if (!ExpandMacros(*this, it.second.Unexpanded, it.second.Expanded)) {
return ReadFileResult::INVALID_MACRO_EXPANSION;
}
}
this->PresetOrder = std::move(presetOrder);
this->Presets = std::move(presetMap);
return ReadFileResult::READ_OK;
}
@@ -817,14 +1501,16 @@ const char* cmCMakePresetsFile::ResultToString(ReadFileResult result)
return "Project preset inherits from user preset";
case ReadFileResult::INVALID_MACRO_EXPANSION:
return "Invalid macro expansion";
case ReadFileResult::BUILD_TEST_PRESETS_UNSUPPORTED:
return "File version must be 2 or higher for build and test preset "
"support.";
}
return "Unknown error";
}
cmCMakePresetsFile::ReadFileResult cmCMakePresetsFile::ReadJSONFile(
const std::string& filename, std::vector<std::string>& presetOrder,
std::map<std::string, PresetPair>& presetMap, bool user)
const std::string& filename, bool user)
{
cmsys::ifstream fin(filename.c_str());
if (!fin) {
@@ -848,6 +1534,12 @@ cmCMakePresetsFile::ReadFileResult cmCMakePresetsFile::ReadJSONFile(
return ReadFileResult::UNRECOGNIZED_VERSION;
}
// 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) {
@@ -866,16 +1558,158 @@ cmCMakePresetsFile::ReadFileResult cmCMakePresetsFile::ReadJSONFile(
return ReadFileResult::UNRECOGNIZED_CMAKE_VERSION;
}
for (auto& preset : presets.Presets) {
for (auto& preset : presets.ConfigurePresets) {
preset.User = user;
if (preset.Name.empty()) {
return ReadFileResult::INVALID_PRESET;
}
if (!presetMap.insert({ preset.Name, { preset, cm::nullopt } }).second) {
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;
}
presetOrder.push_back(preset.Name);
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;
}
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;
}
this->TestPresetOrder.push_back(preset.Name);
}
return ReadFileResult::READ_OK;
}
void cmCMakePresetsFile::ClearPresets()
{
this->ConfigurePresets.clear();
this->BuildPresets.clear();
this->TestPresets.clear();
this->ConfigurePresetOrder.clear();
this->BuildPresetOrder.clear();
this->TestPresetOrder.clear();
}
void cmCMakePresetsFile::PrintPresets(
const std::vector<const cmCMakePresetsFile::Preset*>& presets)
{
if (presets.empty()) {
return;
}
auto longestPresetName =
std::max_element(presets.begin(), presets.end(),
[](const cmCMakePresetsFile::Preset* a,
const cmCMakePresetsFile::Preset* b) {
return a->Name.length() < b->Name.length();
});
auto longestLength = (*longestPresetName)->Name.length();
for (const auto* preset : presets) {
std::cout << " \"" << preset->Name << '"';
const auto& description = preset->DisplayName;
if (!description.empty()) {
for (std::size_t i = 0; i < longestLength - preset->Name.length(); ++i) {
std::cout << ' ';
}
std::cout << " - " << description;
}
std::cout << '\n';
}
}
void cmCMakePresetsFile::PrintConfigurePresetList() const
{
PrintConfigurePresetList([](const ConfigurePreset&) { return true; });
}
void cmCMakePresetsFile::PrintConfigurePresetList(
const std::function<bool(const ConfigurePreset&)>& filter) const
{
std::vector<const cmCMakePresetsFile::Preset*> presets;
for (auto const& p : this->ConfigurePresetOrder) {
auto const& preset = this->ConfigurePresets.at(p);
if (!preset.Unexpanded.Hidden && preset.Expanded &&
filter(preset.Unexpanded)) {
presets.push_back(
static_cast<const cmCMakePresetsFile::Preset*>(&preset.Unexpanded));
}
}
if (!presets.empty()) {
std::cout << "Available configure presets:\n\n";
cmCMakePresetsFile::PrintPresets(presets);
}
}
void cmCMakePresetsFile::PrintBuildPresetList() const
{
std::vector<const cmCMakePresetsFile::Preset*> presets;
for (auto const& p : this->BuildPresetOrder) {
auto const& preset = this->BuildPresets.at(p);
if (!preset.Unexpanded.Hidden && preset.Expanded) {
presets.push_back(
static_cast<const cmCMakePresetsFile::Preset*>(&preset.Unexpanded));
}
}
if (!presets.empty()) {
std::cout << "Available build presets:\n\n";
cmCMakePresetsFile::PrintPresets(presets);
}
}
void cmCMakePresetsFile::PrintTestPresetList() const
{
std::vector<const cmCMakePresetsFile::Preset*> presets;
for (auto const& p : this->TestPresetOrder) {
auto const& preset = this->TestPresets.at(p);
if (!preset.Unexpanded.Hidden && preset.Expanded) {
presets.push_back(
static_cast<const cmCMakePresetsFile::Preset*>(&preset.Unexpanded));
}
}
if (!presets.empty()) {
std::cout << "Available test presets:\n\n";
cmCMakePresetsFile::PrintPresets(presets);
}
}
void cmCMakePresetsFile::PrintAllPresets() const
{
this->PrintConfigurePresetList();
std::cout << std::endl;
this->PrintBuildPresetList();
std::cout << std::endl;
this->PrintTestPresetList();
}
Source/cmCMakePresetsFile.h
+301 -106
View File
@@ -2,6 +2,7 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#pragma once
#include <functional>
#include <map>
#include <string>
#include <utility>
@@ -12,108 +13,6 @@
class cmCMakePresetsFile
{
public:
enum class ArchToolsetStrategy
{
Set,
External,
};
class CacheVariable
{
public:
std::string Type;
std::string Value;
};
class Preset
{
public:
#if __cplusplus < 201703L && (!defined(_MSVC_LANG) || _MSVC_LANG < 201703L)
Preset() = default;
Preset(const Preset& /*other*/) = default;
Preset(Preset&& /*other*/) = default;
Preset& operator=(const Preset& /*other*/) = default;
// The move assignment operators for several STL classes did not become
// noexcept until C++17, which causes some tools to warn about this move
// assignment operator throwing an exception when it shouldn't. Disable the
// move assignment operator until C++17 is enabled.
Preset& operator=(Preset&& /*other*/) = delete;
#endif
std::string Name;
std::vector<std::string> Inherits;
bool Hidden;
bool User;
std::string DisplayName;
std::string Description;
std::string Generator;
std::string Architecture;
cm::optional<ArchToolsetStrategy> ArchitectureStrategy;
std::string Toolset;
cm::optional<ArchToolsetStrategy> ToolsetStrategy;
std::string BinaryDir;
std::map<std::string, cm::optional<CacheVariable>> CacheVariables;
std::map<std::string, cm::optional<std::string>> Environment;
cm::optional<bool> WarnDev;
cm::optional<bool> ErrorDev;
cm::optional<bool> WarnDeprecated;
cm::optional<bool> ErrorDeprecated;
cm::optional<bool> WarnUninitialized;
cm::optional<bool> WarnUnusedCli;
cm::optional<bool> WarnSystemVars;
cm::optional<bool> DebugOutput;
cm::optional<bool> DebugTryCompile;
cm::optional<bool> DebugFind;
};
class UnexpandedPreset : public Preset
{
public:
using Preset::Preset;
UnexpandedPreset() = default;
UnexpandedPreset(const Preset& preset)
: Preset(preset)
{
}
UnexpandedPreset(Preset&& preset)
: Preset(std::move(preset))
{
}
};
class ExpandedPreset : public Preset
{
public:
using Preset::Preset;
ExpandedPreset() = default;
ExpandedPreset(const Preset& preset)
: Preset(preset)
{
}
ExpandedPreset(Preset&& preset)
: Preset(std::move(preset))
{
}
};
class PresetPair
{
public:
UnexpandedPreset Unexpanded;
cm::optional<ExpandedPreset> Expanded;
};
std::string SourceDir;
std::map<std::string, PresetPair> Presets;
std::vector<std::string> PresetOrder;
enum class ReadFileResult
{
READ_OK,
@@ -132,17 +31,313 @@ public:
CYCLIC_PRESET_INHERITANCE,
USER_PRESET_INHERITANCE,
INVALID_MACRO_EXPANSION,
BUILD_TEST_PRESETS_UNSUPPORTED,
};
enum class ArchToolsetStrategy
{
Set,
External,
};
class CacheVariable
{
public:
std::string Type;
std::string Value;
};
class Preset
{
public:
#if __cplusplus < 201703L && (!defined(_MSVC_LANG) || _MSVC_LANG < 201703L)
// The move assignment operators for several STL classes did not become
// noexcept until C++17, which causes some tools to warn about this move
// assignment operator throwing an exception when it shouldn't. Disable the
// move assignment operator until C++17 is enabled.
// Explicitly defining a copy assignment operator prevents the compiler
// from automatically generating a move assignment operator.
Preset& operator=(const Preset& /*other*/) = default;
#endif
virtual ~Preset() = default;
std::string Name;
std::vector<std::string> Inherits;
bool Hidden;
bool User;
std::string DisplayName;
std::string Description;
std::map<std::string, cm::optional<std::string>> Environment;
virtual ReadFileResult VisitPresetInherit(const Preset& parent) = 0;
virtual ReadFileResult VisitPresetBeforeInherit()
{
return ReadFileResult::READ_OK;
}
virtual ReadFileResult VisitPresetAfterInherit()
{
return ReadFileResult::READ_OK;
}
};
class ConfigurePreset : public Preset
{
public:
#if __cplusplus < 201703L && (!defined(_MSVC_LANG) || _MSVC_LANG < 201703L)
// The move assignment operators for several STL classes did not become
// noexcept until C++17, which causes some tools to warn about this move
// assignment operator throwing an exception when it shouldn't. Disable the
// move assignment operator until C++17 is enabled.
// Explicitly defining a copy assignment operator prevents the compiler
// from automatically generating a move assignment operator.
ConfigurePreset& operator=(const ConfigurePreset& /*other*/) = default;
#endif
std::string Generator;
std::string Architecture;
cm::optional<ArchToolsetStrategy> ArchitectureStrategy;
std::string Toolset;
cm::optional<ArchToolsetStrategy> ToolsetStrategy;
std::string BinaryDir;
std::map<std::string, cm::optional<CacheVariable>> CacheVariables;
cm::optional<bool> WarnDev;
cm::optional<bool> ErrorDev;
cm::optional<bool> WarnDeprecated;
cm::optional<bool> ErrorDeprecated;
cm::optional<bool> WarnUninitialized;
cm::optional<bool> WarnUnusedCli;
cm::optional<bool> WarnSystemVars;
cm::optional<bool> DebugOutput;
cm::optional<bool> DebugTryCompile;
cm::optional<bool> DebugFind;
ReadFileResult VisitPresetInherit(const Preset& parent) override;
ReadFileResult VisitPresetBeforeInherit() override;
ReadFileResult VisitPresetAfterInherit() override;
};
class BuildPreset : public Preset
{
public:
#if __cplusplus < 201703L && (!defined(_MSVC_LANG) || _MSVC_LANG < 201703L)
// The move assignment operators for several STL classes did not become
// noexcept until C++17, which causes some tools to warn about this move
// assignment operator throwing an exception when it shouldn't. Disable the
// move assignment operator until C++17 is enabled.
// Explicitly defining a copy assignment operator prevents the compiler
// from automatically generating a move assignment operator.
BuildPreset& operator=(const BuildPreset& /*other*/) = default;
#endif
std::string ConfigurePreset;
cm::optional<bool> InheritConfigureEnvironment;
cm::optional<int> Jobs;
std::vector<std::string> Targets;
std::string Configuration;
cm::optional<bool> CleanFirst;
cm::optional<bool> Verbose;
std::vector<std::string> NativeToolOptions;
ReadFileResult VisitPresetInherit(const Preset& parent) override;
ReadFileResult VisitPresetAfterInherit() override;
};
class TestPreset : public Preset
{
public:
#if __cplusplus < 201703L && (!defined(_MSVC_LANG) || _MSVC_LANG < 201703L)
// The move assignment operators for several STL classes did not become
// noexcept until C++17, which causes some tools to warn about this move
// assignment operator throwing an exception when it shouldn't. Disable the
// move assignment operator until C++17 is enabled.
// Explicitly defining a copy assignment operator prevents the compiler
// from automatically generating a move assignment operator.
TestPreset& operator=(const TestPreset& /*other*/) = default;
#endif
struct OutputOptions
{
enum class VerbosityEnum
{
Default,
Verbose,
Extra
};
cm::optional<bool> ShortProgress;
cm::optional<VerbosityEnum> Verbosity;
cm::optional<bool> Debug;
cm::optional<bool> OutputOnFailure;
cm::optional<bool> Quiet;
std::string OutputLogFile;
cm::optional<bool> LabelSummary;
cm::optional<bool> SubprojectSummary;
cm::optional<int> MaxPassedTestOutputSize;
cm::optional<int> MaxFailedTestOutputSize;
cm::optional<int> MaxTestNameWidth;
};
struct IncludeOptions
{
struct IndexOptions
{
cm::optional<int> Start;
cm::optional<int> End;
cm::optional<int> Stride;
std::vector<int> SpecificTests;
std::string IndexFile;
};
std::string Name;
std::string Label;
cm::optional<IndexOptions> Index;
cm::optional<bool> UseUnion;
};
struct ExcludeOptions
{
struct FixturesOptions
{
std::string Any;
std::string Setup;
std::string Cleanup;
};
std::string Name;
std::string Label;
cm::optional<FixturesOptions> Fixtures;
};
struct FilterOptions
{
cm::optional<IncludeOptions> Include;
cm::optional<ExcludeOptions> Exclude;
};
struct ExecutionOptions
{
enum class ShowOnlyEnum
{
Human,
JsonV1
};
struct RepeatOptions
{
enum class ModeEnum
{
UntilFail,
UntilPass,
AfterTimeout
};
ModeEnum Mode;
int Count;
};
enum class NoTestsActionEnum
{
Default,
Error,
Ignore
};
cm::optional<bool> StopOnFailure;
cm::optional<bool> EnableFailover;
cm::optional<int> Jobs;
std::string ResourceSpecFile;
cm::optional<int> TestLoad;
cm::optional<ShowOnlyEnum> ShowOnly;
cm::optional<bool> RerunFailed;
cm::optional<RepeatOptions> Repeat;
cm::optional<bool> InteractiveDebugging;
cm::optional<bool> ScheduleRandom;
cm::optional<int> Timeout;
cm::optional<NoTestsActionEnum> NoTestsAction;
};
std::string ConfigurePreset;
cm::optional<bool> InheritConfigureEnvironment;
std::string Configuration;
std::vector<std::string> OverwriteConfigurationFile;
cm::optional<OutputOptions> Output;
cm::optional<FilterOptions> Filter;
cm::optional<ExecutionOptions> Execution;
ReadFileResult VisitPresetInherit(const Preset& parent) override;
ReadFileResult VisitPresetAfterInherit() override;
};
template <class T>
class PresetPair
{
public:
T Unexpanded;
cm::optional<T> Expanded;
};
std::map<std::string, PresetPair<ConfigurePreset>> ConfigurePresets;
std::map<std::string, PresetPair<BuildPreset>> BuildPresets;
std::map<std::string, PresetPair<TestPreset>> TestPresets;
std::vector<std::string> ConfigurePresetOrder;
std::vector<std::string> BuildPresetOrder;
std::vector<std::string> TestPresetOrder;
std::string SourceDir;
static std::string GetFilename(const std::string& sourceDir);
static std::string GetUserFilename(const std::string& sourceDir);
ReadFileResult ReadProjectPresets(const std::string& sourceDir,
bool allowNoFiles = false);
static const char* ResultToString(ReadFileResult result);
std::string GetGeneratorForPreset(const std::string& presetName) const
{
auto configurePresetName = presetName;
auto buildPresetIterator = this->BuildPresets.find(presetName);
if (buildPresetIterator != this->BuildPresets.end()) {
configurePresetName =
buildPresetIterator->second.Unexpanded.ConfigurePreset;
} else {
auto testPresetIterator = this->TestPresets.find(presetName);
if (testPresetIterator != this->TestPresets.end()) {
configurePresetName =
testPresetIterator->second.Unexpanded.ConfigurePreset;
}
}
auto configurePresetIterator =
this->ConfigurePresets.find(configurePresetName);
if (configurePresetIterator != this->ConfigurePresets.end()) {
return configurePresetIterator->second.Unexpanded.Generator;
}
// This should only happen if the preset is hidden
// or (for build or test presets) if ConfigurePreset is invalid.
return "";
}
static void PrintPresets(
const std::vector<const cmCMakePresetsFile::Preset*>& presets);
void PrintConfigurePresetList() const;
void PrintConfigurePresetList(
const std::function<bool(const ConfigurePreset&)>& filter) const;
void PrintBuildPresetList() const;
void PrintTestPresetList() const;
void PrintAllPresets() const;
private:
ReadFileResult ReadJSONFile(const std::string& filename,
std::vector<std::string>& presetOrder,
std::map<std::string, PresetPair>& presetMap,
bool user);
ReadFileResult ReadProjectPresetsInternal(bool allowNoFiles);
ReadFileResult ReadJSONFile(const std::string& filename, bool user);
void ClearPresets();
};
Source/cmCTest.cxx
+339 -1
View File
@@ -18,6 +18,7 @@
#include <vector>
#include <cm/memory>
#include <cm/optional>
#include <cm/string_view>
#include <cmext/algorithm>
#include <cmext/string_view>
@@ -38,6 +39,7 @@
# include <unistd.h> // IWYU pragma: keep
#endif
#include "cmCMakePresetsFile.h"
#include "cmCTestBuildAndTestHandler.h"
#include "cmCTestBuildHandler.h"
#include "cmCTestConfigureHandler.h"
@@ -2257,6 +2259,311 @@ bool cmCTest::AddVariableDefinition(const std::string& arg)
return false;
}
void cmCTest::SetPersistentOptionIfNotEmpty(const std::string& value,
const std::string& optionName)
{
if (!value.empty()) {
this->GetTestHandler()->SetPersistentOption(optionName, value.c_str());
this->GetMemCheckHandler()->SetPersistentOption(optionName, value.c_str());
}
}
bool cmCTest::SetArgsFromPreset(const std::string& presetName,
bool listPresets)
{
const auto workingDirectory = cmSystemTools::GetCurrentWorkingDirectory();
cmCMakePresetsFile settingsFile;
auto result = settingsFile.ReadProjectPresets(workingDirectory);
if (result != cmCMakePresetsFile::ReadFileResult::READ_OK) {
cmSystemTools::Error(cmStrCat("Could not read presets from ",
workingDirectory, ": ",
cmCMakePresetsFile::ResultToString(result)));
return false;
}
if (listPresets) {
settingsFile.PrintTestPresetList();
return true;
}
auto presetPair = settingsFile.TestPresets.find(presetName);
if (presetPair == settingsFile.TestPresets.end()) {
cmSystemTools::Error(cmStrCat("No such test preset in ", workingDirectory,
": \"", presetName, '"'));
settingsFile.PrintTestPresetList();
return false;
}
if (presetPair->second.Unexpanded.Hidden) {
cmSystemTools::Error(cmStrCat("Cannot use hidden test preset in ",
workingDirectory, ": \"", presetName, '"'));
settingsFile.PrintTestPresetList();
return false;
}
auto const& expandedPreset = presetPair->second.Expanded;
if (!expandedPreset) {
cmSystemTools::Error(cmStrCat("Could not evaluate test preset \"",
presetName, "\": Invalid macro expansion"));
settingsFile.PrintTestPresetList();
return false;
}
auto configurePresetPair =
settingsFile.ConfigurePresets.find(expandedPreset->ConfigurePreset);
if (configurePresetPair == settingsFile.ConfigurePresets.end()) {
cmSystemTools::Error(cmStrCat("No such configure preset in ",
workingDirectory, ": \"",
expandedPreset->ConfigurePreset, '"'));
settingsFile.PrintConfigurePresetList();
return false;
}
if (configurePresetPair->second.Unexpanded.Hidden) {
cmSystemTools::Error(cmStrCat("Cannot use hidden configure preset in ",
workingDirectory, ": \"",
expandedPreset->ConfigurePreset, '"'));
settingsFile.PrintConfigurePresetList();
return false;
}
auto const& expandedConfigurePreset = configurePresetPair->second.Expanded;
if (!expandedConfigurePreset) {
cmSystemTools::Error(cmStrCat("Could not evaluate configure preset \"",
expandedPreset->ConfigurePreset,
"\": Invalid macro expansion"));
return false;
}
auto presetEnvironment = expandedPreset->Environment;
for (auto const& var : presetEnvironment) {
if (var.second) {
cmSystemTools::PutEnv(cmStrCat(var.first, '=', *var.second));
}
}
if (!expandedPreset->Configuration.empty()) {
this->SetConfigType(expandedPreset->Configuration);
}
// Set build directory to value specified by the configure preset.
this->AddCTestConfigurationOverwrite(
cmStrCat("BuildDirectory=", expandedConfigurePreset->BinaryDir));
for (const auto& kvp : expandedPreset->OverwriteConfigurationFile) {
this->AddCTestConfigurationOverwrite(kvp);
}
if (expandedPreset->Output) {
this->Impl->TestProgressOutput =
expandedPreset->Output->ShortProgress.value_or(false);
if (expandedPreset->Output->Verbosity) {
const auto& verbosity = *expandedPreset->Output->Verbosity;
switch (verbosity) {
case cmCMakePresetsFile::TestPreset::OutputOptions::VerbosityEnum::
Extra:
this->Impl->ExtraVerbose = true;
// intentional fallthrough
case cmCMakePresetsFile::TestPreset::OutputOptions::VerbosityEnum::
Verbose:
this->Impl->Verbose = true;
break;
case cmCMakePresetsFile::TestPreset::OutputOptions::VerbosityEnum::
Default:
default:
// leave default settings
break;
}
}
this->Impl->Debug = expandedPreset->Output->Debug.value_or(false);
this->Impl->ShowLineNumbers =
expandedPreset->Output->Debug.value_or(false);
this->Impl->OutputTestOutputOnTestFailure =
expandedPreset->Output->OutputOnFailure.value_or(false);
this->Impl->Quiet = expandedPreset->Output->Quiet.value_or(false);
if (!expandedPreset->Output->OutputLogFile.empty()) {
this->SetOutputLogFileName(expandedPreset->Output->OutputLogFile);
}
this->Impl->LabelSummary =
expandedPreset->Output->LabelSummary.value_or(true);
this->Impl->SubprojectSummary =
expandedPreset->Output->SubprojectSummary.value_or(true);
if (expandedPreset->Output->MaxPassedTestOutputSize) {
this->Impl->TestHandler.SetTestOutputSizePassed(
*expandedPreset->Output->MaxPassedTestOutputSize);
}
if (expandedPreset->Output->MaxFailedTestOutputSize) {
this->Impl->TestHandler.SetTestOutputSizeFailed(
*expandedPreset->Output->MaxFailedTestOutputSize);
}
if (expandedPreset->Output->MaxTestNameWidth) {
this->Impl->MaxTestNameWidth = *expandedPreset->Output->MaxTestNameWidth;
}
}
if (expandedPreset->Filter) {
if (expandedPreset->Filter->Include) {
this->SetPersistentOptionIfNotEmpty(
expandedPreset->Filter->Include->Name, "IncludeRegularExpression");
this->SetPersistentOptionIfNotEmpty(
expandedPreset->Filter->Include->Label, "LabelRegularExpression");
if (expandedPreset->Filter->Include->Index) {
if (expandedPreset->Filter->Include->Index->IndexFile.empty()) {
const auto& start = expandedPreset->Filter->Include->Index->Start;
const auto& end = expandedPreset->Filter->Include->Index->End;
const auto& stride = expandedPreset->Filter->Include->Index->Stride;
std::string indexOptions;
indexOptions += (start ? std::to_string(*start) : "") + ",";
indexOptions += (end ? std::to_string(*end) : "") + ",";
indexOptions += (stride ? std::to_string(*stride) : "") + ",";
indexOptions +=
cmJoin(expandedPreset->Filter->Include->Index->SpecificTests, ",");
this->SetPersistentOptionIfNotEmpty(indexOptions,
"TestsToRunInformation");
} else {
this->SetPersistentOptionIfNotEmpty(
expandedPreset->Filter->Include->Index->IndexFile,
"TestsToRunInformation");
}
}
if (expandedPreset->Filter->Include->UseUnion.value_or(false)) {
this->GetTestHandler()->SetPersistentOption("UseUnion", "true");
this->GetMemCheckHandler()->SetPersistentOption("UseUnion", "true");
}
}
if (expandedPreset->Filter->Exclude) {
this->SetPersistentOptionIfNotEmpty(
expandedPreset->Filter->Exclude->Name, "ExcludeRegularExpression");
this->SetPersistentOptionIfNotEmpty(
expandedPreset->Filter->Exclude->Label,
"ExcludeLabelRegularExpression");
if (expandedPreset->Filter->Exclude->Fixtures) {
this->SetPersistentOptionIfNotEmpty(
expandedPreset->Filter->Exclude->Fixtures->Any,
"ExcludeFixtureRegularExpression");
this->SetPersistentOptionIfNotEmpty(
expandedPreset->Filter->Exclude->Fixtures->Setup,
"ExcludeFixtureSetupRegularExpression");
this->SetPersistentOptionIfNotEmpty(
expandedPreset->Filter->Exclude->Fixtures->Cleanup,
"ExcludeFixtureCleanupRegularExpression");
}
}
}
if (expandedPreset->Execution) {
this->Impl->StopOnFailure =
expandedPreset->Execution->StopOnFailure.value_or(false);
this->Impl->Failover =
expandedPreset->Execution->EnableFailover.value_or(false);
if (expandedPreset->Execution->Jobs) {
auto jobs = *expandedPreset->Execution->Jobs;
this->SetParallelLevel(jobs);
this->Impl->ParallelLevelSetInCli = true;
}
this->SetPersistentOptionIfNotEmpty(
expandedPreset->Execution->ResourceSpecFile, "ResourceSpecFile");
if (expandedPreset->Execution->TestLoad) {
auto testLoad = *expandedPreset->Execution->TestLoad;
this->SetTestLoad(testLoad);
}
if (expandedPreset->Execution->ShowOnly) {
this->Impl->ShowOnly = true;
switch (*expandedPreset->Execution->ShowOnly) {
case cmCMakePresetsFile::TestPreset::ExecutionOptions::ShowOnlyEnum::
JsonV1:
this->Impl->Quiet = true;
this->Impl->OutputAsJson = true;
this->Impl->OutputAsJsonVersion = 1;
break;
case cmCMakePresetsFile::TestPreset::ExecutionOptions::ShowOnlyEnum::
Human:
// intentional fallthrough (human is the default)
default:
break;
}
}
if (expandedPreset->Execution->RerunFailed.value_or(false)) {
this->GetTestHandler()->SetPersistentOption("RerunFailed", "true");
this->GetMemCheckHandler()->SetPersistentOption("RerunFailed", "true");
}
if (expandedPreset->Execution->Repeat) {
this->Impl->RepeatCount = expandedPreset->Execution->Repeat->Count;
switch (expandedPreset->Execution->Repeat->Mode) {
case cmCMakePresetsFile::TestPreset::ExecutionOptions::RepeatOptions::
ModeEnum::UntilFail:
this->Impl->RepeatMode = cmCTest::Repeat::UntilFail;
break;
case cmCMakePresetsFile::TestPreset::ExecutionOptions::RepeatOptions::
ModeEnum::UntilPass:
this->Impl->RepeatMode = cmCTest::Repeat::UntilPass;
break;
case cmCMakePresetsFile::TestPreset::ExecutionOptions::RepeatOptions::
ModeEnum::AfterTimeout:
this->Impl->RepeatMode = cmCTest::Repeat::AfterTimeout;
break;
default:
// should never default since mode is required
return false;
}
}
if (expandedPreset->Execution->InteractiveDebugging) {
this->Impl->InteractiveDebugMode =
*expandedPreset->Execution->InteractiveDebugging;
}
if (expandedPreset->Execution->ScheduleRandom.value_or(false)) {
this->Impl->ScheduleType = "Random";
}
if (expandedPreset->Execution->Timeout) {
this->Impl->GlobalTimeout =
cmDuration(*expandedPreset->Execution->Timeout);
}
if (expandedPreset->Execution->NoTestsAction) {
switch (*expandedPreset->Execution->NoTestsAction) {
case cmCMakePresetsFile::TestPreset::ExecutionOptions::
NoTestsActionEnum::Error:
this->Impl->NoTestsMode = cmCTest::NoTests::Error;
break;
case cmCMakePresetsFile::TestPreset::ExecutionOptions::
NoTestsActionEnum::Ignore:
this->Impl->NoTestsMode = cmCTest::NoTests::Ignore;
break;
case cmCMakePresetsFile::TestPreset::ExecutionOptions::
NoTestsActionEnum::Default:
break;
default:
// should never default
return false;
}
}
}
return true;
}
// the main entry point of ctest, called from main
int cmCTest::Run(std::vector<std::string>& args, std::string* output)
{
@@ -2268,6 +2575,37 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
// copy the command line
cm::append(this->Impl->InitialCommandLineArguments, args);
// check if a test preset was specified
bool listPresets =
find(args.begin(), args.end(), "--list-presets") != args.end();
auto it = find(args.begin(), args.end(), "--preset");
if (listPresets || it != args.end()) {
std::string errormsg;
bool success;
if (listPresets) {
// If listing presets we don't need a presetName
success = this->SetArgsFromPreset("", listPresets);
} else {
if (++it != args.end()) {
auto presetName = *it;
success = this->SetArgsFromPreset(presetName, listPresets);
} else {
cmSystemTools::Error("'--preset' requires an argument");
success = false;
}
}
if (listPresets) {
return success ? 0 : 1;
}
if (!success) {
return 1;
}
}
// process the command line arguments
for (size_t i = 1; i < args.size(); ++i) {
// handle the simple commandline arguments
@@ -2339,7 +2677,7 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
this->Impl->ScheduleType = "Random";
}
// pass the argument to all the handlers as well, but i may no longer be
// pass the argument to all the handlers as well, but it may no longer be
// set to what it was originally so I'm not sure this is working as
// intended
for (auto& handler : this->Impl->GetTestingHandlers()) {
Source/cmCTest.h
+6
View File
@@ -461,6 +461,9 @@ public:
void SetRunCurrentScript(bool value);
private:
void SetPersistentOptionIfNotEmpty(const std::string& value,
const std::string& optionName);
int GenerateNotesFile(const std::string& files);
void BlockTestErrorDiagnostics();
@@ -484,6 +487,9 @@ private:
/** add a variable definition from a command line -D value */
bool AddVariableDefinition(const std::string& arg);
/** set command line arguments read from a test preset */
bool SetArgsFromPreset(const std::string& presetName, bool listPresets);
/** parse and process most common command line arguments */
bool HandleCommandLineArguments(size_t& i, std::vector<std::string>& args,
std::string& errormsg);
Source/cmake.cxx
+170 -54
View File
@@ -726,6 +726,17 @@ void cmake::LoadEnvironmentPresets()
readGeneratorVar("CMAKE_GENERATOR_TOOLSET", this->GeneratorToolset);
}
namespace {
enum class ListPresets
{
None,
Configure,
Build,
Test,
All,
};
}
// Parse the args
void cmake::SetArgs(const std::vector<std::string>& args)
{
@@ -738,7 +749,8 @@ void cmake::SetArgs(const std::vector<std::string>& args)
std::string profilingFormat;
std::string profilingOutput;
std::string presetName;
bool listPresets = false;
ListPresets listPresets = ListPresets::None;
#endif
auto SourceArgLambda = [](std::string const& value, cmake* state) -> bool {
@@ -995,11 +1007,27 @@ void cmake::SetArgs(const std::vector<std::string>& args)
presetName = value;
return true;
});
arguments.emplace_back("--list-presets", CommandArgument::Values::Zero,
[&](std::string const&, cmake*) -> bool {
listPresets = true;
return true;
});
arguments.emplace_back(
"--list-presets", CommandArgument::Values::ZeroOrOne,
[&](std::string const& value, cmake*) -> bool {
if (value.empty() || value == "configure") {
listPresets = ListPresets::Configure;
} else if (value == "build") {
listPresets = ListPresets::Build;
} else if (value == "test") {
listPresets = ListPresets::Test;
} else if (value == "all") {
listPresets = ListPresets::All;
} else {
cmSystemTools::Error(
"Invalid value specified for --list-presets.\n"
"Valid values are configure, build, test, or all. "
"When no value is passed the default is configure.");
return false;
}
return true;
});
#endif
@@ -1119,7 +1147,7 @@ void cmake::SetArgs(const std::vector<std::string>& args)
}
#if !defined(CMAKE_BOOTSTRAP)
if (listPresets || !presetName.empty()) {
if (listPresets != ListPresets::None || !presetName.empty()) {
cmCMakePresetsFile settingsFile;
auto result = settingsFile.ReadProjectPresets(this->GetHomeDirectory());
if (result != cmCMakePresetsFile::ReadFileResult::READ_OK) {
@@ -1128,12 +1156,24 @@ void cmake::SetArgs(const std::vector<std::string>& args)
": ", cmCMakePresetsFile::ResultToString(result)));
return;
}
if (listPresets) {
this->PrintPresetList(settingsFile);
if (listPresets != ListPresets::None) {
if (listPresets == ListPresets::Configure) {
this->PrintPresetList(settingsFile);
} else if (listPresets == ListPresets::Build) {
settingsFile.PrintBuildPresetList();
} else if (listPresets == ListPresets::Test) {
settingsFile.PrintTestPresetList();
} else if (listPresets == ListPresets::All) {
settingsFile.PrintAllPresets();
}
this->SetWorkingMode(WorkingMode::HELP_MODE);
return;
}
auto preset = settingsFile.Presets.find(presetName);
if (preset == settingsFile.Presets.end()) {
auto preset = settingsFile.ConfigurePresets.find(presetName);
if (preset == settingsFile.ConfigurePresets.end()) {
cmSystemTools::Error(cmStrCat("No such preset in ",
this->GetHomeDirectory(), ": \"",
presetName, '"'));
@@ -1562,44 +1602,16 @@ void cmake::PrintPresetList(const cmCMakePresetsFile& file) const
{
std::vector<GeneratorInfo> generators;
this->GetRegisteredGenerators(generators, false);
auto filter =
[&generators](const cmCMakePresetsFile::ConfigurePreset& preset) -> bool {
auto condition = [&preset](const GeneratorInfo& info) -> bool {
return info.name == preset.Generator;
};
auto it = std::find_if(generators.begin(), generators.end(), condition);
return it != generators.end();
};
std::vector<cmCMakePresetsFile::UnexpandedPreset> presets;
for (auto const& p : file.PresetOrder) {
auto const& preset = file.Presets.at(p);
if (!preset.Unexpanded.Hidden && preset.Expanded &&
std::find_if(generators.begin(), generators.end(),
[&preset](const GeneratorInfo& info) {
return info.name == preset.Unexpanded.Generator;
}) != generators.end()) {
presets.push_back(preset.Unexpanded);
}
}
if (presets.empty()) {
return;
}
std::cout << "Available presets:\n\n";
auto longestPresetName =
std::max_element(presets.begin(), presets.end(),
[](const cmCMakePresetsFile::UnexpandedPreset& a,
const cmCMakePresetsFile::UnexpandedPreset& b) {
return a.Name.length() < b.Name.length();
});
auto longestLength = longestPresetName->Name.length();
for (auto const& preset : presets) {
std::cout << " \"" << preset.Name << '"';
auto const& description = preset.DisplayName;
if (!description.empty()) {
for (std::size_t i = 0; i < longestLength - preset.Name.length(); ++i) {
std::cout << ' ';
}
std::cout << " - " << description;
}
std::cout << '\n';
}
file.PrintConfigurePresetList(filter);
}
#endif
@@ -3068,15 +3080,119 @@ std::vector<std::string> cmake::GetDebugConfigs()
return configs;
}
int cmake::Build(int jobs, const std::string& dir,
const std::vector<std::string>& targets,
const std::string& config,
const std::vector<std::string>& nativeOptions, bool clean,
bool verbose)
int cmake::Build(int jobs, std::string dir, std::vector<std::string> targets,
std::string config, std::vector<std::string> nativeOptions,
bool clean, bool verbose, const std::string& presetName,
bool listPresets)
{
this->SetHomeDirectory("");
this->SetHomeOutputDirectory("");
#if !defined(CMAKE_BOOTSTRAP)
if (!presetName.empty() || listPresets) {
this->SetHomeDirectory(cmSystemTools::GetCurrentWorkingDirectory());
this->SetHomeOutputDirectory(cmSystemTools::GetCurrentWorkingDirectory());
cmCMakePresetsFile settingsFile;
auto result = settingsFile.ReadProjectPresets(this->GetHomeDirectory());
if (result != cmCMakePresetsFile::ReadFileResult::READ_OK) {
cmSystemTools::Error(
cmStrCat("Could not read presets from ", this->GetHomeDirectory(),
": ", cmCMakePresetsFile::ResultToString(result)));
return 1;
}
if (listPresets) {
settingsFile.PrintBuildPresetList();
return 0;
}
auto presetPair = settingsFile.BuildPresets.find(presetName);
if (presetPair == settingsFile.BuildPresets.end()) {
cmSystemTools::Error(cmStrCat("No such build preset in ",
this->GetHomeDirectory(), ": \"",
presetName, '"'));
settingsFile.PrintBuildPresetList();
return 1;
}
if (presetPair->second.Unexpanded.Hidden) {
cmSystemTools::Error(cmStrCat("Cannot use hidden build preset in ",
this->GetHomeDirectory(), ": \"",
presetName, '"'));
settingsFile.PrintBuildPresetList();
return 1;
}
auto const& expandedPreset = presetPair->second.Expanded;
if (!expandedPreset) {
cmSystemTools::Error(cmStrCat("Could not evaluate build preset \"",
presetName,
"\": Invalid macro expansion"));
settingsFile.PrintBuildPresetList();
return 1;
}
auto configurePresetPair =
settingsFile.ConfigurePresets.find(expandedPreset->ConfigurePreset);
if (configurePresetPair == settingsFile.ConfigurePresets.end()) {
cmSystemTools::Error(cmStrCat("No such configure preset in ",
this->GetHomeDirectory(), ": \"",
expandedPreset->ConfigurePreset, '"'));
this->PrintPresetList(settingsFile);
return 1;
}
if (configurePresetPair->second.Unexpanded.Hidden) {
cmSystemTools::Error(cmStrCat("Cannot use hidden configure preset in ",
this->GetHomeDirectory(), ": \"",
expandedPreset->ConfigurePreset, '"'));
this->PrintPresetList(settingsFile);
return 1;
}
auto const& expandedConfigurePreset = configurePresetPair->second.Expanded;
if (!expandedConfigurePreset) {
cmSystemTools::Error(cmStrCat("Could not evaluate configure preset \"",
expandedPreset->ConfigurePreset,
"\": Invalid macro expansion"));
return 1;
}
dir = expandedConfigurePreset->BinaryDir;
this->UnprocessedPresetEnvironment = expandedPreset->Environment;
this->ProcessPresetEnvironment();
if (jobs == cmake::DEFAULT_BUILD_PARALLEL_LEVEL && expandedPreset->Jobs) {
jobs = *expandedPreset->Jobs;
}
if (targets.empty()) {
targets.insert(targets.begin(), expandedPreset->Targets.begin(),
expandedPreset->Targets.end());
}
if (config.empty()) {
config = expandedPreset->Configuration;
}
if (!clean && expandedPreset->CleanFirst) {
clean = *expandedPreset->CleanFirst;
}
if (!verbose && expandedPreset->Verbose) {
verbose = *expandedPreset->Verbose;
}
if (nativeOptions.empty()) {
nativeOptions.insert(nativeOptions.begin(),
expandedPreset->NativeToolOptions.begin(),
expandedPreset->NativeToolOptions.end());
}
}
#endif
if (!cmSystemTools::FileIsDirectory(dir)) {
std::cerr << "Error: " << dir << " is not a directory\n";
return 1;
Source/cmake.h
+5 -5
View File
@@ -238,7 +238,7 @@ public:
bool CreateAndSetGlobalGenerator(const std::string& name, bool allowArch);
#ifndef CMAKE_BOOTSTRAP
//! Print list of presets
//! Print list of configure presets
void PrintPresetList(const cmCMakePresetsFile& file) const;
#endif
@@ -556,10 +556,10 @@ public:
cmListFileBacktrace const& backtrace = cmListFileBacktrace()) const;
//! run the --build option
int Build(int jobs, const std::string& dir,
const std::vector<std::string>& targets, const std::string& config,
const std::vector<std::string>& nativeOptions, bool clean,
bool verbose);
int Build(int jobs, std::string dir, std::vector<std::string> targets,
std::string config, std::vector<std::string> nativeOptions,
bool clean, bool verbose, const std::string& presetName,
bool listPresets);
//! run the --open option
bool Open(const std::string& dir, bool dryRun);
Source/cmakemain.cxx
+41 -8
View File
@@ -425,6 +425,8 @@ int do_build(int ac, char const* const* av)
bool foundClean = false;
bool foundNonClean = false;
bool verbose = cmSystemTools::HasEnv("VERBOSE");
std::string presetName;
bool listPresets = false;
auto jLambda = [&](std::string const& value) -> bool {
jobs = extract_job_number("-j", value);
@@ -464,6 +466,16 @@ int do_build(int ac, char const* const* av)
cmCommandLineArgument<bool(std::string const& value)>;
std::vector<CommandArgument> arguments = {
CommandArgument{ "--preset", CommandArgument::Values::One,
[&](std::string const& value) -> bool {
presetName = value;
return true;
} },
CommandArgument{ "--list-presets", CommandArgument::Values::Zero,
[&](std::string const&) -> bool {
listPresets = true;
return true;
} },
CommandArgument{ "-j", CommandArgument::Values::ZeroOrOne, jLambda },
CommandArgument{ "--parallel", CommandArgument::Values::ZeroOrOne,
parallelLambda },
@@ -494,11 +506,26 @@ int do_build(int ac, char const* const* av)
};
if (ac >= 3) {
dir = cmSystemTools::CollapseFullPath(av[2]);
std::vector<std::string> inputArgs;
inputArgs.reserve(ac - 3);
cm::append(inputArgs, av + 3, av + ac);
bool hasPreset = false;
for (int i = 2; i < ac; ++i) {
if (strcmp(av[i], "--list-presets") == 0 ||
strcmp(av[i], "--preset") == 0) {
hasPreset = true;
break;
}
}
if (hasPreset) {
inputArgs.reserve(ac - 2);
cm::append(inputArgs, av + 2, av + ac);
} else {
dir = cmSystemTools::CollapseFullPath(av[2]);
inputArgs.reserve(ac - 3);
cm::append(inputArgs, av + 3, av + ac);
}
decltype(inputArgs.size()) i = 0;
for (; i < inputArgs.size() && !nativeOptionsPassed; ++i) {
@@ -551,12 +578,16 @@ int do_build(int ac, char const* const* av)
}
}
if (dir.empty()) {
if (dir.empty() && presetName.empty() && !listPresets) {
/* clang-format off */
std::cerr <<
"Usage: cmake --build <dir> [options] [-- [native-options]]\n"
"Usage: cmake --build [<dir> | --preset <preset>] [options] [-- [native-options]]\n"
"Options:\n"
" <dir> = Project binary directory to be built.\n"
" --preset <preset>\n"
" = Specify a build preset.\n"
" --list-presets\n"
" = List available build presets.\n"
" --parallel [<jobs>], -j [<jobs>]\n"
" = Build in parallel using the given number of jobs. \n"
" If <jobs> is omitted the native build tool's \n"
@@ -587,8 +618,10 @@ int do_build(int ac, char const* const* av)
cm.SetProgressCallback([&cm](const std::string& msg, float prog) {
cmakemainProgressCallback(msg, prog, &cm);
});
return cm.Build(jobs, dir, targets, config, nativeOptions, cleanFirst,
verbose);
return cm.Build(jobs, std::move(dir), std::move(targets), std::move(config),
std::move(nativeOptions), cleanFirst, verbose, presetName,
listPresets);
#endif
}
Source/ctest.cxx
+2
View File
@@ -26,6 +26,8 @@ static const char* cmDocumentationUsage[][2] = { { nullptr,
{ nullptr, nullptr } };
static const char* cmDocumentationOptions[][2] = {
{ "--preset <preset>", "Read arguments from a test preset." },
{ "--list-presets", "List available test presets." },
{ "-C <cfg>, --build-config <cfg>", "Choose configuration to test." },
{ "--progress", "Enable short progress output from tests." },
{ "-V,--verbose", "Enable verbose output from tests." },