in Source/cmake.cxx [951:1703]
void cmake::SetArgs(std::vector<std::string> const& args)
{
this->cmdArgs = args;
bool haveToolset = false;
bool havePlatform = false;
bool haveBArg = false;
bool haveCMLName = false;
std::string possibleUnknownArg;
std::string extraProvidedPath;
#if !defined(CMAKE_BOOTSTRAP)
std::string profilingFormat;
std::string profilingOutput;
std::string presetName;
ListPresets listPresets = ListPresets::None;
#endif
auto EmptyStringArgLambda = [](std::string const&, cmake* state) -> bool {
state->IssueMessage(
MessageType::WARNING,
"Ignoring empty string (\"\") provided on the command line.");
return true;
};
auto SourceArgLambda = [](std::string const& value, cmake* state) -> bool {
if (value.empty()) {
cmSystemTools::Error("No source directory specified for -S");
return false;
}
state->SetHomeDirectoryViaCommandLine(
cmSystemTools::ToNormalizedPathOnDisk(value));
return true;
};
auto BuildArgLambda = [&](std::string const& value, cmake* state) -> bool {
if (value.empty()) {
cmSystemTools::Error("No build directory specified for -B");
return false;
}
state->SetHomeOutputDirectory(
cmSystemTools::ToNormalizedPathOnDisk(value));
haveBArg = true;
return true;
};
auto PlatformLambda = [&](std::string const& value, cmake* state) -> bool {
if (havePlatform) {
cmSystemTools::Error("Multiple -A options not allowed");
return false;
}
state->SetGeneratorPlatform(value);
havePlatform = true;
return true;
};
auto ToolsetLambda = [&](std::string const& value, cmake* state) -> bool {
if (haveToolset) {
cmSystemTools::Error("Multiple -T options not allowed");
return false;
}
state->SetGeneratorToolset(value);
haveToolset = true;
return true;
};
auto CMakeListsFileLambda = [&](std::string const& value,
cmake* state) -> bool {
if (haveCMLName) {
cmSystemTools::Error("Multiple --project-file options not allowed");
return false;
}
state->SetCMakeListName(value);
haveCMLName = true;
return true;
};
std::vector<CommandArgument> arguments = {
CommandArgument{ "", CommandArgument::Values::Zero, EmptyStringArgLambda },
CommandArgument{ "-S", "No source directory specified for -S",
CommandArgument::Values::One,
CommandArgument::RequiresSeparator::No, SourceArgLambda },
CommandArgument{ "-H", "No source directory specified for -H",
CommandArgument::Values::One,
CommandArgument::RequiresSeparator::No, SourceArgLambda },
CommandArgument{ "-O", CommandArgument::Values::Zero,
IgnoreAndTrueLambda },
CommandArgument{ "-B", "No build directory specified for -B",
CommandArgument::Values::One,
CommandArgument::RequiresSeparator::No, BuildArgLambda },
CommandArgument{ "--fresh", CommandArgument::Values::Zero,
[](std::string const&, cmake* cm) -> bool {
cm->FreshCache = true;
return true;
} },
CommandArgument{ "-P", "-P must be followed by a file name.",
CommandArgument::Values::One,
CommandArgument::RequiresSeparator::No,
IgnoreAndTrueLambda },
CommandArgument{ "-D", "-D must be followed with VAR=VALUE.",
CommandArgument::Values::One,
CommandArgument::RequiresSeparator::No,
IgnoreAndTrueLambda },
CommandArgument{ "-C", "-C must be followed by a file name.",
CommandArgument::Values::One,
CommandArgument::RequiresSeparator::No,
IgnoreAndTrueLambda },
CommandArgument{
"-U", "-U must be followed with VAR.", CommandArgument::Values::One,
CommandArgument::RequiresSeparator::No, IgnoreAndTrueLambda },
CommandArgument{ "-W", "-W must be followed with [no-]<name>.",
CommandArgument::Values::One,
CommandArgument::RequiresSeparator::No,
IgnoreAndTrueLambda },
CommandArgument{ "-A", "No platform specified for -A",
CommandArgument::Values::One,
CommandArgument::RequiresSeparator::No, PlatformLambda },
CommandArgument{ "-T", "No toolset specified for -T",
CommandArgument::Values::One,
CommandArgument::RequiresSeparator::No, ToolsetLambda },
CommandArgument{ "--toolchain", "No file specified for --toolchain",
CommandArgument::Values::One, IgnoreAndTrueLambda },
CommandArgument{ "--install-prefix",
"No install directory specified for --install-prefix",
CommandArgument::Values::One, IgnoreAndTrueLambda },
CommandArgument{ "--check-build-system", CommandArgument::Values::Two,
[](std::string const& value, cmake* state) -> bool {
cmList values{ value };
state->CheckBuildSystemArgument = values[0];
state->ClearBuildSystem = (atoi(values[1].c_str()) > 0);
return true;
} },
CommandArgument{ "--check-stamp-file", CommandArgument::Values::One,
[](std::string const& value, cmake* state) -> bool {
state->CheckStampFile = value;
return true;
} },
CommandArgument{ "--check-stamp-list", CommandArgument::Values::One,
[](std::string const& value, cmake* state) -> bool {
state->CheckStampList = value;
return true;
} },
CommandArgument{ "--regenerate-during-build",
CommandArgument::Values::Zero,
[](std::string const&, cmake* state) -> bool {
state->RegenerateDuringBuild = true;
return true;
} },
CommandArgument{ "--find-package", CommandArgument::Values::Zero,
IgnoreAndTrueLambda },
CommandArgument{ "--graphviz", "No file specified for --graphviz",
CommandArgument::Values::One,
[](std::string const& value, cmake* state) -> bool {
state->SetGraphVizFile(
cmSystemTools::ToNormalizedPathOnDisk(value));
return true;
} },
CommandArgument{ "--debug-trycompile", CommandArgument::Values::Zero,
[](std::string const&, cmake* state) -> bool {
std::cout << "debug trycompile on\n";
state->DebugTryCompileOn();
return true;
} },
CommandArgument{ "--debug-output", CommandArgument::Values::Zero,
[](std::string const&, cmake* state) -> bool {
std::cout << "Running with debug output on.\n";
state->SetDebugOutputOn(true);
return true;
} },
CommandArgument{ "--log-level", "Invalid level specified for --log-level",
CommandArgument::Values::One,
[](std::string const& value, cmake* state) -> bool {
auto const logLevel = StringToLogLevel(value);
if (logLevel == Message::LogLevel::LOG_UNDEFINED) {
cmSystemTools::Error(
"Invalid level specified for --log-level");
return false;
}
state->SetLogLevel(logLevel);
state->LogLevelWasSetViaCLI = true;
return true;
} },
// This is supported for backward compatibility. This option only
// appeared in the 3.15.x release series and was renamed to
// --log-level in 3.16.0
CommandArgument{ "--loglevel", "Invalid level specified for --loglevel",
CommandArgument::Values::One,
[](std::string const& value, cmake* state) -> bool {
auto const logLevel = StringToLogLevel(value);
if (logLevel == Message::LogLevel::LOG_UNDEFINED) {
cmSystemTools::Error(
"Invalid level specified for --loglevel");
return false;
}
state->SetLogLevel(logLevel);
state->LogLevelWasSetViaCLI = true;
return true;
} },
CommandArgument{ "--log-context", CommandArgument::Values::Zero,
[](std::string const&, cmake* state) -> bool {
state->SetShowLogContext(true);
return true;
} },
CommandArgument{ "--project-file",
"No filename specified for --project-file",
CommandArgument::Values::One, CMakeListsFileLambda },
CommandArgument{ "--debug-server-port", CommandArgument::Values::One,
[](std::string const& value, cmake* state) -> bool {
state->SetDebugServerPort(atoi(value.c_str()));
return true;
} },
CommandArgument{ "--debug-token-path", CommandArgument::Values::One,
[](std::string const& value, cmake* state) -> bool {
state->SetDebugServerTokenPath(value);
return true;
} },
CommandArgument{
"--debug-find", CommandArgument::Values::Zero,
[](std::string const&, cmake* state) -> bool {
std::cout << "Running with debug output on for the `find` commands.\n";
state->SetDebugFindOutput(true);
return true;
} },
CommandArgument{
"--debug-find-pkg", "Provide a package argument for --debug-find-pkg",
CommandArgument::Values::One, CommandArgument::RequiresSeparator::Yes,
[](std::string const& value, cmake* state) -> bool {
std::vector<std::string> find_pkgs(cmTokenize(value, ','));
std::cout << "Running with debug output on for the 'find' commands "
"for package(s)";
for (auto const& v : find_pkgs) {
std::cout << ' ' << v;
state->SetDebugFindOutputPkgs(v);
}
std::cout << ".\n";
return true;
} },
CommandArgument{
"--debug-find-var", CommandArgument::Values::One,
CommandArgument::RequiresSeparator::Yes,
[](std::string const& value, cmake* state) -> bool {
std::vector<std::string> find_vars(cmTokenize(value, ','));
std::cout << "Running with debug output on for the variable(s)";
for (auto const& v : find_vars) {
std::cout << ' ' << v;
state->SetDebugFindOutputVars(v);
}
std::cout << ".\n";
return true;
} },
CommandArgument{ "--trace", CommandArgument::Values::Zero,
[](std::string const&, cmake* state) -> bool {
std::cout << "Put cmake in trace mode.\n";
state->SetTrace(true);
state->SetTraceExpand(false);
return true;
} },
CommandArgument{ "--trace-expand", CommandArgument::Values::Zero,
[](std::string const&, cmake* state) -> bool {
std::cout << "Put cmake in trace mode, but with "
"variables expanded.\n";
state->SetTrace(true);
state->SetTraceExpand(true);
return true;
} },
CommandArgument{
"--trace-format", "Invalid format specified for --trace-format",
CommandArgument::Values::One,
[](std::string const& value, cmake* state) -> bool {
std::cout << "Put cmake in trace mode and sets the "
"trace output format.\n";
state->SetTrace(true);
auto const traceFormat = StringToTraceFormat(value);
if (traceFormat == TraceFormat::Undefined) {
cmSystemTools::Error("Invalid format specified for --trace-format. "
"Valid formats are human, json-v1.");
return false;
}
state->SetTraceFormat(traceFormat);
return true;
} },
CommandArgument{ "--trace-source", "No file specified for --trace-source",
CommandArgument::Values::OneOrMore,
[](std::string const& values, cmake* state) -> bool {
std::cout << "Put cmake in trace mode, but output only "
"lines of a specified file. Multiple "
"options are allowed.\n";
for (auto file :
cmSystemTools::SplitString(values, ';')) {
cmSystemTools::ConvertToUnixSlashes(file);
state->AddTraceSource(file);
}
state->SetTrace(true);
return true;
} },
CommandArgument{ "--trace-redirect",
"No file specified for --trace-redirect",
CommandArgument::Values::One,
[](std::string const& value, cmake* state) -> bool {
std::cout
<< "Put cmake in trace mode and redirect trace "
"output to a file instead of stderr.\n";
std::string file(value);
cmSystemTools::ConvertToUnixSlashes(file);
state->SetTraceFile(file);
state->SetTrace(true);
return true;
} },
CommandArgument{ "--warn-uninitialized", CommandArgument::Values::Zero,
[](std::string const&, cmake* state) -> bool {
std::cout << "Warn about uninitialized values.\n";
state->SetWarnUninitialized(true);
return true;
} },
CommandArgument{ "--warn-unused-vars", CommandArgument::Values::Zero,
IgnoreAndTrueLambda }, // Option was removed.
CommandArgument{ "--no-warn-unused-cli", CommandArgument::Values::Zero,
[](std::string const&, cmake* state) -> bool {
std::cout
<< "Not searching for unused variables given on the "
"command line.\n";
state->SetWarnUnusedCli(false);
return true;
} },
CommandArgument{
"--check-system-vars", CommandArgument::Values::Zero,
[](std::string const&, cmake* state) -> bool {
std::cout << "Also check system files when warning about unused and "
"uninitialized variables.\n";
state->SetCheckSystemVars(true);
return true;
} },
CommandArgument{
"--compile-no-warning-as-error", CommandArgument::Values::Zero,
[](std::string const&, cmake* state) -> bool {
std::cout << "Ignoring COMPILE_WARNING_AS_ERROR target property and "
"CMAKE_COMPILE_WARNING_AS_ERROR variable.\n";
state->SetIgnoreCompileWarningAsError(true);
return true;
} },
CommandArgument{
"--link-no-warning-as-error", CommandArgument::Values::Zero,
[](std::string const&, cmake* state) -> bool {
std::cout << "Ignoring LINK_WARNING_AS_ERROR target property and "
"CMAKE_LINK_WARNING_AS_ERROR variable.\n";
state->SetIgnoreLinkWarningAsError(true);
return true;
} },
#ifndef CMAKE_BOOTSTRAP
CommandArgument{ "--sarif-output", "No file specified for --sarif-output",
CommandArgument::Values::One,
[](std::string const& value, cmake* state) -> bool {
state->SarifFilePath =
cmSystemTools::ToNormalizedPathOnDisk(value);
state->SarifFileOutput = true;
return true;
} },
#endif
CommandArgument{ "--debugger", CommandArgument::Values::Zero,
[](std::string const&, cmake* state) -> bool {
#ifdef CMake_ENABLE_DEBUGGER
std::cout << "Running with debugger on.\n";
state->SetDebuggerOn(true);
return true;
#else
static_cast<void>(state);
cmSystemTools::Error(
"CMake was not built with support for --debugger");
return false;
#endif
} },
CommandArgument{ "--debugger-pipe",
"No path specified for --debugger-pipe",
CommandArgument::Values::One,
[](std::string const& value, cmake* state) -> bool {
#ifdef CMake_ENABLE_DEBUGGER
state->DebuggerPipe = value;
return true;
#else
static_cast<void>(value);
static_cast<void>(state);
cmSystemTools::Error("CMake was not built with support "
"for --debugger-pipe");
return false;
#endif
} },
CommandArgument{ "--debugger-dap-log",
"No file specified for --debugger-dap-log",
CommandArgument::Values::One,
[](std::string const& value, cmake* state) -> bool {
#ifdef CMake_ENABLE_DEBUGGER
state->DebuggerDapLogFile =
cmSystemTools::ToNormalizedPathOnDisk(value);
return true;
#else
static_cast<void>(value);
static_cast<void>(state);
cmSystemTools::Error("CMake was not built with support "
"for --debugger-dap-log");
return false;
#endif
} },
};
#if defined(CMAKE_HAVE_VS_GENERATORS)
arguments.emplace_back("--vs-solution-file", CommandArgument::Values::One,
[](std::string const& value, cmake* state) -> bool {
state->VSSolutionFile = value;
return true;
});
#endif
#if !defined(CMAKE_BOOTSTRAP)
arguments.emplace_back("--profiling-format",
"No format specified for --profiling-format",
CommandArgument::Values::One,
[&](std::string const& value, cmake*) -> bool {
profilingFormat = value;
return true;
});
arguments.emplace_back(
"--profiling-output", "No path specified for --profiling-output",
CommandArgument::Values::One,
[&profilingOutput](std::string const& value, cmake*) -> bool {
profilingOutput = cmSystemTools::ToNormalizedPathOnDisk(value);
return true;
});
arguments.emplace_back("--preset", "No preset specified for --preset",
CommandArgument::Values::One,
[&](std::string const& value, cmake*) -> bool {
presetName = value;
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 == "package") {
listPresets = ListPresets::Package;
} else if (value == "workflow") {
listPresets = ListPresets::Workflow;
} else if (value == "all") {
listPresets = ListPresets::All;
} else {
cmSystemTools::Error(
"Invalid value specified for --list-presets.\n"
"Valid values are configure, build, test, package, or all. "
"When no value is passed the default is configure.");
return false;
}
return true;
});
#endif
bool badGeneratorName = false;
CommandArgument generatorCommand(
"-G", "No generator specified for -G", CommandArgument::Values::One,
CommandArgument::RequiresSeparator::No,
[&](std::string const& value, cmake* state) -> bool {
bool valid = state->CreateAndSetGlobalGenerator(value);
badGeneratorName = !valid;
return valid;
});
for (decltype(args.size()) i = 1; i < args.size(); ++i) {
// iterate each argument
std::string const& arg = args[i];
if (this->GetWorkingMode() == SCRIPT_MODE && arg == "--") {
// Stop processing CMake args and avoid possible errors
// when arbitrary args are given to CMake script.
break;
}
// Generator flag has special handling for when to print help
// so it becomes the exception
if (generatorCommand.matches(arg)) {
bool parsed = generatorCommand.parse(arg, i, args, this);
if (!parsed && !badGeneratorName) {
this->PrintGeneratorList();
return;
}
continue;
}
bool matched = false;
bool parsedCorrectly = true; // needs to be true so we can ignore
// arguments so as -E
for (auto const& m : arguments) {
if (m.matches(arg)) {
matched = true;
parsedCorrectly = m.parse(arg, i, args, this);
break;
}
}
// We have an issue where arguments to a "-P" script mode
// can be provided before the "-P" argument. This means
// that we need to lazily check this argument after checking
// all args.
// Additionally it can't be the source/binary tree location
if (!parsedCorrectly) {
cmSystemTools::Error("Run 'cmake --help' for all supported options.");
exit(1);
} else if (!matched && cmHasLiteralPrefix(arg, "-")) {
possibleUnknownArg = arg;
} else if (!matched) {
bool parsedDirectory = this->SetDirectoriesFromFile(arg);
if (!parsedDirectory) {
extraProvidedPath = arg;
}
}
}
if (!extraProvidedPath.empty() && this->GetWorkingMode() == NORMAL_MODE) {
this->IssueMessage(MessageType::WARNING,
cmStrCat("Ignoring extra path from command line:\n \"",
extraProvidedPath, "\""));
}
if (!possibleUnknownArg.empty() && this->GetWorkingMode() != SCRIPT_MODE) {
cmSystemTools::Error(cmStrCat("Unknown argument ", possibleUnknownArg));
cmSystemTools::Error("Run 'cmake --help' for all supported options.");
exit(1);
}
// Empty instance, platform and toolset if only a generator is specified
if (this->GlobalGenerator) {
this->GeneratorInstance = "";
if (!this->GeneratorPlatformSet) {
this->GeneratorPlatform = "";
}
if (!this->GeneratorToolsetSet) {
this->GeneratorToolset = "";
}
}
#if !defined(CMAKE_BOOTSTRAP)
if (!profilingOutput.empty() || !profilingFormat.empty()) {
if (profilingOutput.empty()) {
cmSystemTools::Error(
"--profiling-format specified but no --profiling-output!");
return;
}
if (profilingFormat == "google-trace"_s) {
try {
this->ProfilingOutput =
cm::make_unique<cmMakefileProfilingData>(profilingOutput);
} catch (std::runtime_error& e) {
cmSystemTools::Error(
cmStrCat("Could not start profiling: ", e.what()));
return;
}
} else {
cmSystemTools::Error("Invalid format specified for --profiling-format");
return;
}
}
#endif
bool const haveSourceDir = !this->GetHomeDirectory().empty();
bool const haveBinaryDir = !this->GetHomeOutputDirectory().empty();
bool const havePreset =
#ifdef CMAKE_BOOTSTRAP
false;
#else
!presetName.empty();
#endif
if (this->CurrentWorkingMode == cmake::NORMAL_MODE && !haveSourceDir &&
!haveBinaryDir && !havePreset) {
this->IssueMessage(
MessageType::WARNING,
"No source or binary directory provided. Both will be assumed to be "
"the same as the current working directory, but note that this "
"warning will become a fatal error in future CMake releases.");
}
if (!haveSourceDir) {
this->SetHomeDirectory(cmSystemTools::GetLogicalWorkingDirectory());
}
if (!haveBinaryDir) {
this->SetHomeOutputDirectory(cmSystemTools::GetLogicalWorkingDirectory());
}
#if !defined(CMAKE_BOOTSTRAP)
if (listPresets != ListPresets::None || !presetName.empty()) {
cmCMakePresetsGraph presetsGraph;
auto result = presetsGraph.ReadProjectPresets(this->GetHomeDirectory());
if (result != true) {
std::string errorMsg =
cmStrCat("Could not read presets from ", this->GetHomeDirectory(), ":",
presetsGraph.parseState.GetErrorMessage());
cmSystemTools::Error(errorMsg);
return;
}
if (listPresets != ListPresets::None) {
if (listPresets == ListPresets::Configure) {
this->PrintPresetList(presetsGraph);
} else if (listPresets == ListPresets::Build) {
presetsGraph.PrintBuildPresetList();
} else if (listPresets == ListPresets::Test) {
presetsGraph.PrintTestPresetList();
} else if (listPresets == ListPresets::Package) {
presetsGraph.PrintPackagePresetList();
} else if (listPresets == ListPresets::Workflow) {
presetsGraph.PrintWorkflowPresetList();
} else if (listPresets == ListPresets::All) {
presetsGraph.PrintAllPresets();
}
this->SetWorkingMode(WorkingMode::HELP_MODE);
return;
}
auto preset = presetsGraph.ConfigurePresets.find(presetName);
if (preset == presetsGraph.ConfigurePresets.end()) {
cmSystemTools::Error(cmStrCat("No such preset in ",
this->GetHomeDirectory(), ": \"",
presetName, '"'));
this->PrintPresetList(presetsGraph);
return;
}
if (preset->second.Unexpanded.Hidden) {
cmSystemTools::Error(cmStrCat("Cannot use hidden preset in ",
this->GetHomeDirectory(), ": \"",
presetName, '"'));
this->PrintPresetList(presetsGraph);
return;
}
auto const& expandedPreset = preset->second.Expanded;
if (!expandedPreset) {
cmSystemTools::Error(cmStrCat("Could not evaluate preset \"",
preset->second.Unexpanded.Name,
"\": Invalid macro expansion"));
return;
}
if (!expandedPreset->ConditionResult) {
cmSystemTools::Error(cmStrCat("Could not use disabled preset \"",
preset->second.Unexpanded.Name, "\""));
return;
}
if (!this->State->IsCacheLoaded() && !haveBArg &&
!expandedPreset->BinaryDir.empty()) {
this->SetHomeOutputDirectory(expandedPreset->BinaryDir);
}
if (!this->GlobalGenerator && !expandedPreset->Generator.empty()) {
if (!this->CreateAndSetGlobalGenerator(expandedPreset->Generator)) {
return;
}
}
this->UnprocessedPresetVariables = expandedPreset->CacheVariables;
this->UnprocessedPresetEnvironment = expandedPreset->Environment;
if (!expandedPreset->InstallDir.empty() &&
!this->State->GetInitializedCacheValue("CMAKE_INSTALL_PREFIX")) {
this->UnprocessedPresetVariables["CMAKE_INSTALL_PREFIX"] = {
"PATH", expandedPreset->InstallDir
};
}
if (!expandedPreset->ToolchainFile.empty() &&
!this->State->GetInitializedCacheValue("CMAKE_TOOLCHAIN_FILE")) {
this->UnprocessedPresetVariables["CMAKE_TOOLCHAIN_FILE"] = {
"FILEPATH", expandedPreset->ToolchainFile
};
}
if (!expandedPreset->ArchitectureStrategy ||
expandedPreset->ArchitectureStrategy ==
cmCMakePresetsGraph::ArchToolsetStrategy::Set) {
if (!this->GeneratorPlatformSet &&
!expandedPreset->Architecture.empty()) {
this->SetGeneratorPlatform(expandedPreset->Architecture);
}
}
if (!expandedPreset->ToolsetStrategy ||
expandedPreset->ToolsetStrategy ==
cmCMakePresetsGraph::ArchToolsetStrategy::Set) {
if (!this->GeneratorToolsetSet && !expandedPreset->Toolset.empty()) {
this->SetGeneratorToolset(expandedPreset->Toolset);
}
}
if (!expandedPreset->GraphVizFile.empty()) {
if (this->GraphVizFile.empty()) {
this->SetGraphVizFile(
cmSystemTools::CollapseFullPath(expandedPreset->GraphVizFile));
}
}
this->SetWarningFromPreset("dev", expandedPreset->WarnDev,
expandedPreset->ErrorDev);
this->SetWarningFromPreset("deprecated", expandedPreset->WarnDeprecated,
expandedPreset->ErrorDeprecated);
if (expandedPreset->WarnUninitialized == true) {
this->SetWarnUninitialized(true);
}
if (expandedPreset->WarnUnusedCli == false) {
this->SetWarnUnusedCli(false);
}
if (expandedPreset->WarnSystemVars == true) {
this->SetCheckSystemVars(true);
}
if (expandedPreset->DebugOutput == true) {
this->SetDebugOutputOn(true);
}
if (expandedPreset->DebugTryCompile == true) {
this->DebugTryCompileOn();
}
if (expandedPreset->DebugFind == true) {
this->SetDebugFindOutput(true);
}
if (expandedPreset->TraceMode &&
expandedPreset->TraceMode !=
cmCMakePresetsGraph::TraceEnableMode::Disable) {
this->SetTrace(true);
if (expandedPreset->TraceMode ==
cmCMakePresetsGraph::TraceEnableMode::Expand) {
this->SetTraceExpand(true);
}
}
if (expandedPreset->TraceFormat) {
this->SetTrace(true);
this->SetTraceFormat(*expandedPreset->TraceFormat);
}
if (!expandedPreset->TraceSource.empty()) {
this->SetTrace(true);
for (std::string const& filePaths : expandedPreset->TraceSource) {
this->AddTraceSource(filePaths);
}
}
if (!expandedPreset->TraceRedirect.empty()) {
this->SetTrace(true);
this->SetTraceFile(expandedPreset->TraceRedirect);
}
}
#endif
}