mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-01-04 21:00:17 -06:00
Code Issues Packages Projects Releases Wiki Activity

use _s to construct static string_views at several places

Browse Source 
This should avoid the runtime strlen() call.
This commit is contained in:
Rolf Eike Beer
2020-03-24 17:51:39 +01:00
parent 94de927cab
commit ec7928ef26
4 changed files with 116 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
Source/CTest/cmCTestTestHandler.cxx
View File

@@ -18,12 +18,14 @@
#include <utility> #include <utility>
#include <cm/memory> #include <cm/memory>
#include <cm/string_view>
#include "cmsys/FStream.hxx" #include "cmsys/FStream.hxx"
#include <cmsys/Base64.h> #include <cmsys/Base64.h>
#include <cmsys/Directory.hxx> #include <cmsys/Directory.hxx>
#include <cmsys/RegularExpression.hxx> #include <cmsys/RegularExpression.hxx>
#include "cm_static_string_view.hxx"
#include "cm_utf8.h" #include "cm_utf8.h"
#include "cmAlgorithms.h" #include "cmAlgorithms.h"
@@ -2154,7 +2156,7 @@ bool cmCTestTestHandler::SetTestsProperties(
for (std::string const& t : tests) { for (std::string const& t : tests) {
for (cmCTestTestProperties& rt : this->TestList) { for (cmCTestTestProperties& rt : this->TestList) {
if (t == rt.Name) { if (t == rt.Name) {
if (key == "_BACKTRACE_TRIPLES") { if (key == "_BACKTRACE_TRIPLES"_s) {
std::vector<std::string> triples; std::vector<std::string> triples;
// allow empty args in the triples // allow empty args in the triples
cmExpandList(val, triples, true); cmExpandList(val, triples, true);
@@ -2178,70 +2180,70 @@ bool cmCTestTestHandler::SetTestsProperties(
rt.Backtrace = rt.Backtrace.Push(fc); rt.Backtrace = rt.Backtrace.Push(fc);
} }
} }
} else if (key == "WILL_FAIL") { } else if (key == "WILL_FAIL"_s) {
rt.WillFail = cmIsOn(val); rt.WillFail = cmIsOn(val);
} else if (key == "DISABLED") { } else if (key == "DISABLED"_s) {
rt.Disabled = cmIsOn(val); rt.Disabled = cmIsOn(val);
} else if (key == "ATTACHED_FILES") { } else if (key == "ATTACHED_FILES"_s) {
cmExpandList(val, rt.AttachedFiles); cmExpandList(val, rt.AttachedFiles);
} else if (key == "ATTACHED_FILES_ON_FAIL") { } else if (key == "ATTACHED_FILES_ON_FAIL"_s) {
cmExpandList(val, rt.AttachOnFail); cmExpandList(val, rt.AttachOnFail);
} else if (key == "RESOURCE_LOCK") { } else if (key == "RESOURCE_LOCK"_s) {
std::vector<std::string> lval = cmExpandedList(val); std::vector<std::string> lval = cmExpandedList(val);
rt.LockedResources.insert(lval.begin(), lval.end()); rt.LockedResources.insert(lval.begin(), lval.end());
} else if (key == "FIXTURES_SETUP") { } else if (key == "FIXTURES_SETUP"_s) {
std::vector<std::string> lval = cmExpandedList(val); std::vector<std::string> lval = cmExpandedList(val);
rt.FixturesSetup.insert(lval.begin(), lval.end()); rt.FixturesSetup.insert(lval.begin(), lval.end());
} else if (key == "FIXTURES_CLEANUP") { } else if (key == "FIXTURES_CLEANUP"_s) {
std::vector<std::string> lval = cmExpandedList(val); std::vector<std::string> lval = cmExpandedList(val);
rt.FixturesCleanup.insert(lval.begin(), lval.end()); rt.FixturesCleanup.insert(lval.begin(), lval.end());
} else if (key == "FIXTURES_REQUIRED") { } else if (key == "FIXTURES_REQUIRED"_s) {
std::vector<std::string> lval = cmExpandedList(val); std::vector<std::string> lval = cmExpandedList(val);
rt.FixturesRequired.insert(lval.begin(), lval.end()); rt.FixturesRequired.insert(lval.begin(), lval.end());
} else if (key == "TIMEOUT") { } else if (key == "TIMEOUT"_s) {
rt.Timeout = cmDuration(atof(val.c_str())); rt.Timeout = cmDuration(atof(val.c_str()));
rt.ExplicitTimeout = true; rt.ExplicitTimeout = true;
} else if (key == "COST") { } else if (key == "COST"_s) {
rt.Cost = static_cast<float>(atof(val.c_str())); rt.Cost = static_cast<float>(atof(val.c_str()));
} else if (key == "REQUIRED_FILES") { } else if (key == "REQUIRED_FILES"_s) {
cmExpandList(val, rt.RequiredFiles); cmExpandList(val, rt.RequiredFiles);
} else if (key == "RUN_SERIAL") { } else if (key == "RUN_SERIAL"_s) {
rt.RunSerial = cmIsOn(val); rt.RunSerial = cmIsOn(val);
} else if (key == "FAIL_REGULAR_EXPRESSION") { } else if (key == "FAIL_REGULAR_EXPRESSION"_s) {
std::vector<std::string> lval = cmExpandedList(val); std::vector<std::string> lval = cmExpandedList(val);
for (std::string const& cr : lval) { for (std::string const& cr : lval) {
rt.ErrorRegularExpressions.emplace_back(cr, cr); rt.ErrorRegularExpressions.emplace_back(cr, cr);
} }
} else if (key == "SKIP_REGULAR_EXPRESSION") { } else if (key == "SKIP_REGULAR_EXPRESSION"_s) {
std::vector<std::string> lval = cmExpandedList(val); std::vector<std::string> lval = cmExpandedList(val);
for (std::string const& cr : lval) { for (std::string const& cr : lval) {
rt.SkipRegularExpressions.emplace_back(cr, cr); rt.SkipRegularExpressions.emplace_back(cr, cr);
} }
} else if (key == "PROCESSORS") { } else if (key == "PROCESSORS"_s) {
rt.Processors = atoi(val.c_str()); rt.Processors = atoi(val.c_str());
if (rt.Processors < 1) { if (rt.Processors < 1) {
rt.Processors = 1; rt.Processors = 1;
} }
} else if (key == "PROCESSOR_AFFINITY") { } else if (key == "PROCESSOR_AFFINITY"_s) {
rt.WantAffinity = cmIsOn(val); rt.WantAffinity = cmIsOn(val);
} else if (key == "RESOURCE_GROUPS") { } else if (key == "RESOURCE_GROUPS"_s) {
if (!ParseResourceGroupsProperty(val, rt.ResourceGroups)) { if (!ParseResourceGroupsProperty(val, rt.ResourceGroups)) {
return false; return false;
} }
} else if (key == "SKIP_RETURN_CODE") { } else if (key == "SKIP_RETURN_CODE"_s) {
rt.SkipReturnCode = atoi(val.c_str()); rt.SkipReturnCode = atoi(val.c_str());
if (rt.SkipReturnCode < 0 || rt.SkipReturnCode > 255) { if (rt.SkipReturnCode < 0 || rt.SkipReturnCode > 255) {
rt.SkipReturnCode = -1; rt.SkipReturnCode = -1;
} }
} else if (key == "DEPENDS") { } else if (key == "DEPENDS"_s) {
cmExpandList(val, rt.Depends); cmExpandList(val, rt.Depends);
} else if (key == "ENVIRONMENT") { } else if (key == "ENVIRONMENT"_s) {
cmExpandList(val, rt.Environment); cmExpandList(val, rt.Environment);
} else if (key == "LABELS") { } else if (key == "LABELS"_s) {
std::vector<std::string> Labels = cmExpandedList(val); std::vector<std::string> Labels = cmExpandedList(val);
rt.Labels.insert(rt.Labels.end(), Labels.begin(), Labels.end()); rt.Labels.insert(rt.Labels.end(), Labels.begin(), Labels.end());
// sort the array // sort the array
@@ -2249,7 +2251,7 @@ bool cmCTestTestHandler::SetTestsProperties(
// remove duplicates // remove duplicates
auto new_end = std::unique(rt.Labels.begin(), rt.Labels.end()); auto new_end = std::unique(rt.Labels.begin(), rt.Labels.end());
rt.Labels.erase(new_end, rt.Labels.end()); rt.Labels.erase(new_end, rt.Labels.end());
} else if (key == "MEASUREMENT") { } else if (key == "MEASUREMENT"_s) {
size_t pos = val.find_first_of('='); size_t pos = val.find_first_of('=');
if (pos != std::string::npos) { if (pos != std::string::npos) {
std::string mKey = val.substr(0, pos); std::string mKey = val.substr(0, pos);
@@ -2258,14 +2260,14 @@ bool cmCTestTestHandler::SetTestsProperties(
} else { } else {
rt.Measurements[val] = "1"; rt.Measurements[val] = "1";
} }
} else if (key == "PASS_REGULAR_EXPRESSION") { } else if (key == "PASS_REGULAR_EXPRESSION"_s) {
std::vector<std::string> lval = cmExpandedList(val); std::vector<std::string> lval = cmExpandedList(val);
for (std::string const& cr : lval) { for (std::string const& cr : lval) {
rt.RequiredRegularExpressions.emplace_back(cr, cr); rt.RequiredRegularExpressions.emplace_back(cr, cr);
} }
} else if (key == "WORKING_DIRECTORY") { } else if (key == "WORKING_DIRECTORY"_s) {
rt.Directory = val; rt.Directory = val;
} else if (key == "TIMEOUT_AFTER_MATCH") { } else if (key == "TIMEOUT_AFTER_MATCH"_s) {
std::vector<std::string> propArgs = cmExpandedList(val); std::vector<std::string> propArgs = cmExpandedList(val);
if (propArgs.size() != 2) { if (propArgs.size() != 2) {
cmCTestLog(this->CTest, WARNING, cmCTestLog(this->CTest, WARNING,
@@ -2305,16 +2307,16 @@ bool cmCTestTestHandler::SetDirectoryProperties(
} }
++it; // skip PROPERTIES ++it; // skip PROPERTIES
for (; it != args.end(); ++it) { for (; it != args.end(); ++it) {
std::string key = *it; std::string const& key = *it;
++it; ++it;
if (it == args.end()) { if (it == args.end()) {
break; break;
} }
std::string val = *it; std::string const& val = *it;
for (cmCTestTestProperties& rt : this->TestList) { for (cmCTestTestProperties& rt : this->TestList) {
std::string cwd = cmSystemTools::GetCurrentWorkingDirectory(); std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
if (cwd == rt.Directory) { if (cwd == rt.Directory) {
if (key == "LABELS") { if (key == "LABELS"_s) {
std::vector<std::string> DirectoryLabels = cmExpandedList(val); std::vector<std::string> DirectoryLabels = cmExpandedList(val);
rt.Labels.insert(rt.Labels.end(), DirectoryLabels.begin(), rt.Labels.insert(rt.Labels.end(), DirectoryLabels.begin(),
DirectoryLabels.end()); DirectoryLabels.end());

129
Source/cmCTest.cxx
View File

@@ -36,6 +36,8 @@
# include <unistd.h> // IWYU pragma: keep # include <unistd.h> // IWYU pragma: keep
#endif #endif
#include "cm_static_string_view.hxx"
#include "cmCTestBuildAndTestHandler.h" #include "cmCTestBuildAndTestHandler.h"
#include "cmCTestBuildHandler.h" #include "cmCTestBuildHandler.h"
#include "cmCTestConfigureHandler.h" #include "cmCTestConfigureHandler.h"
@@ -1815,10 +1817,10 @@ void cmCTest::ErrorMessageUnknownDashDValue(std::string& val)
<< " ctest -D NightlyMemoryCheck" << std::endl); << " ctest -D NightlyMemoryCheck" << std::endl);
} }
bool cmCTest::CheckArgument(const std::string& arg, const char* varg1, bool cmCTest::CheckArgument(const std::string& arg, cm::string_view varg1,
const char* varg2) const char* varg2)
{ {
return (varg1 && arg == varg1) || (varg2 && arg == varg2); return (arg == varg1) || (varg2 && arg == varg2);
} }
// Processes one command line argument (and its arguments if any) // Processes one command line argument (and its arguments if any)
@@ -1828,9 +1830,9 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
std::string& errormsg) std::string& errormsg)
{ {
std::string arg = args[i]; std::string arg = args[i];
if (this->CheckArgument(arg, "-F")) { if (this->CheckArgument(arg, "-F"_s)) {
this->Impl->Failover = true; this->Impl->Failover = true;
} else if (this->CheckArgument(arg, "-j", "--parallel") && } else if (this->CheckArgument(arg, "-j"_s, "--parallel") &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
int plevel = atoi(args[i].c_str()); int plevel = atoi(args[i].c_str());
@@ -1842,7 +1844,7 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
this->Impl->ParallelLevelSetInCli = true; this->Impl->ParallelLevelSetInCli = true;
} }
else if (this->CheckArgument(arg, "--repeat-until-fail")) { else if (this->CheckArgument(arg, "--repeat-until-fail"_s)) {
if (i >= args.size() - 1) { if (i >= args.size() - 1) {
errormsg = "'--repeat-until-fail' requires an argument"; errormsg = "'--repeat-until-fail' requires an argument";
return false; return false;
@@ -1854,8 +1856,8 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
i++; i++;
long repeat = 1; long repeat = 1;
if (!cmStrToLong(args[i], &repeat)) { if (!cmStrToLong(args[i], &repeat)) {
errormsg = errormsg = cmStrCat("'--repeat-until-fail' given non-integer value '",
"'--repeat-until-fail' given non-integer value '" + args[i] + "'"; args[i], "'");
return false; return false;
} }
this->Impl->RepeatCount = static_cast<int>(repeat); this->Impl->RepeatCount = static_cast<int>(repeat);
@@ -1864,7 +1866,7 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
} }
} }
else if (this->CheckArgument(arg, "--repeat")) { else if (this->CheckArgument(arg, "--repeat"_s)) {
if (i >= args.size() - 1) { if (i >= args.size() - 1) {
errormsg = "'--repeat' requires an argument"; errormsg = "'--repeat' requires an argument";
return false; return false;
@@ -1892,12 +1894,12 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
} }
} }
} else { } else {
errormsg = "'--repeat' given invalid value '" + args[i] + "'"; errormsg = cmStrCat("'--repeat' given invalid value '", args[i], "'");
return false; return false;
} }
} }
else if (this->CheckArgument(arg, "--test-load") && i < args.size() - 1) { else if (this->CheckArgument(arg, "--test-load"_s) && i < args.size() - 1) {
i++; i++;
unsigned long load; unsigned long load;
if (cmStrToULong(args[i], &load)) { if (cmStrToULong(args[i], &load)) {
@@ -1908,65 +1910,65 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
} }
} }
else if (this->CheckArgument(arg, "--no-compress-output")) { else if (this->CheckArgument(arg, "--no-compress-output"_s)) {
this->Impl->CompressTestOutput = false; this->Impl->CompressTestOutput = false;
} }
else if (this->CheckArgument(arg, "--print-labels")) { else if (this->CheckArgument(arg, "--print-labels"_s)) {
this->Impl->PrintLabels = true; this->Impl->PrintLabels = true;
} }
else if (this->CheckArgument(arg, "--http1.0")) { else if (this->CheckArgument(arg, "--http1.0"_s)) {
this->Impl->UseHTTP10 = true; this->Impl->UseHTTP10 = true;
} }
else if (this->CheckArgument(arg, "--timeout") && i < args.size() - 1) { else if (this->CheckArgument(arg, "--timeout"_s) && i < args.size() - 1) {
i++; i++;
auto timeout = cmDuration(atof(args[i].c_str())); auto timeout = cmDuration(atof(args[i].c_str()));
this->Impl->GlobalTimeout = timeout; this->Impl->GlobalTimeout = timeout;
} }
else if (this->CheckArgument(arg, "--stop-time") && i < args.size() - 1) { else if (this->CheckArgument(arg, "--stop-time"_s) && i < args.size() - 1) {
i++; i++;
this->SetStopTime(args[i]); this->SetStopTime(args[i]);
} }
else if (this->CheckArgument(arg, "-C", "--build-config") && else if (this->CheckArgument(arg, "-C"_s, "--build-config") &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
this->SetConfigType(args[i].c_str()); this->SetConfigType(args[i].c_str());
} }
else if (this->CheckArgument(arg, "--debug")) { else if (this->CheckArgument(arg, "--debug"_s)) {
this->Impl->Debug = true; this->Impl->Debug = true;
this->Impl->ShowLineNumbers = true; this->Impl->ShowLineNumbers = true;
} else if (this->CheckArgument(arg, "--group") && i < args.size() - 1) { } else if (this->CheckArgument(arg, "--group"_s) && i < args.size() - 1) {
i++; i++;
this->Impl->SpecificGroup = args[i]; this->Impl->SpecificGroup = args[i];
} }
// This is an undocumented / deprecated option. // This is an undocumented / deprecated option.
// "Track" has been renamed to "Group". // "Track" has been renamed to "Group".
else if (this->CheckArgument(arg, "--track") && i < args.size() - 1) { else if (this->CheckArgument(arg, "--track"_s) && i < args.size() - 1) {
i++; i++;
this->Impl->SpecificGroup = args[i]; this->Impl->SpecificGroup = args[i];
} else if (this->CheckArgument(arg, "--show-line-numbers")) { } else if (this->CheckArgument(arg, "--show-line-numbers"_s)) {
this->Impl->ShowLineNumbers = true; this->Impl->ShowLineNumbers = true;
} else if (this->CheckArgument(arg, "--no-label-summary")) { } else if (this->CheckArgument(arg, "--no-label-summary"_s)) {
this->Impl->LabelSummary = false; this->Impl->LabelSummary = false;
} else if (this->CheckArgument(arg, "--no-subproject-summary")) { } else if (this->CheckArgument(arg, "--no-subproject-summary"_s)) {
this->Impl->SubprojectSummary = false; this->Impl->SubprojectSummary = false;
} else if (this->CheckArgument(arg, "-Q", "--quiet")) { } else if (this->CheckArgument(arg, "-Q"_s, "--quiet")) {
this->Impl->Quiet = true; this->Impl->Quiet = true;
} else if (this->CheckArgument(arg, "--progress")) { } else if (this->CheckArgument(arg, "--progress"_s)) {
this->Impl->TestProgressOutput = true; this->Impl->TestProgressOutput = true;
} else if (this->CheckArgument(arg, "-V", "--verbose")) { } else if (this->CheckArgument(arg, "-V"_s, "--verbose")) {
this->Impl->Verbose = true; this->Impl->Verbose = true;
} else if (this->CheckArgument(arg, "-VV", "--extra-verbose")) { } else if (this->CheckArgument(arg, "-VV"_s, "--extra-verbose")) {
this->Impl->ExtraVerbose = true; this->Impl->ExtraVerbose = true;
this->Impl->Verbose = true; this->Impl->Verbose = true;
} else if (this->CheckArgument(arg, "--output-on-failure")) { } else if (this->CheckArgument(arg, "--output-on-failure"_s)) {
this->Impl->OutputTestOutputOnTestFailure = true; this->Impl->OutputTestOutputOnTestFailure = true;
} else if (this->CheckArgument(arg, "--test-output-size-passed") && } else if (this->CheckArgument(arg, "--test-output-size-passed"_s) &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
long outputSize; long outputSize;
@@ -1977,7 +1979,7 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
"Invalid value for '--test-output-size-passed': " << args[i] "Invalid value for '--test-output-size-passed': " << args[i]
<< "\n"); << "\n");
} }
} else if (this->CheckArgument(arg, "--test-output-size-failed") && } else if (this->CheckArgument(arg, "--test-output-size-failed"_s) &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
long outputSize; long outputSize;
@@ -1988,7 +1990,7 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
"Invalid value for '--test-output-size-failed': " << args[i] "Invalid value for '--test-output-size-failed': " << args[i]
<< "\n"); << "\n");
} }
} else if (this->CheckArgument(arg, "-N", "--show-only")) { } else if (this->CheckArgument(arg, "-N"_s, "--show-only")) {
this->Impl->ShowOnly = true; this->Impl->ShowOnly = true;
} else if (cmHasLiteralPrefix(arg, "--show-only=")) { } else if (cmHasLiteralPrefix(arg, "--show-only=")) {
this->Impl->ShowOnly = true; this->Impl->ShowOnly = true;
@@ -2008,25 +2010,25 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
} }
} }
else if (this->CheckArgument(arg, "-O", "--output-log") && else if (this->CheckArgument(arg, "-O"_s, "--output-log") &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
this->SetOutputLogFileName(args[i].c_str()); this->SetOutputLogFileName(args[i].c_str());
} }
else if (this->CheckArgument(arg, "--tomorrow-tag")) { else if (this->CheckArgument(arg, "--tomorrow-tag"_s)) {
this->Impl->TomorrowTag = true; this->Impl->TomorrowTag = true;
} else if (this->CheckArgument(arg, "--force-new-ctest-process")) { } else if (this->CheckArgument(arg, "--force-new-ctest-process"_s)) {
this->Impl->ForceNewCTestProcess = true; this->Impl->ForceNewCTestProcess = true;
} else if (this->CheckArgument(arg, "-W", "--max-width") && } else if (this->CheckArgument(arg, "-W"_s, "--max-width") &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
this->Impl->MaxTestNameWidth = atoi(args[i].c_str()); this->Impl->MaxTestNameWidth = atoi(args[i].c_str());
} else if (this->CheckArgument(arg, "--interactive-debug-mode") && } else if (this->CheckArgument(arg, "--interactive-debug-mode"_s) &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
this->Impl->InteractiveDebugMode = cmIsOn(args[i]); this->Impl->InteractiveDebugMode = cmIsOn(args[i]);
} else if (this->CheckArgument(arg, "--submit-index") && } else if (this->CheckArgument(arg, "--submit-index"_s) &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
this->Impl->SubmitIndex = atoi(args[i].c_str()); this->Impl->SubmitIndex = atoi(args[i].c_str());
@@ -2035,10 +2037,10 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
} }
} }
else if (this->CheckArgument(arg, "--overwrite") && i < args.size() - 1) { else if (this->CheckArgument(arg, "--overwrite"_s) && i < args.size() - 1) {
i++; i++;
this->AddCTestConfigurationOverwrite(args[i]); this->AddCTestConfigurationOverwrite(args[i]);
} else if (this->CheckArgument(arg, "-A", "--add-notes") && } else if (this->CheckArgument(arg, "-A"_s, "--add-notes") &&
i < args.size() - 1) { i < args.size() - 1) {
this->Impl->ProduceXML = true; this->Impl->ProduceXML = true;
this->SetTest("Notes"); this->SetTest("Notes");
@@ -2063,31 +2065,31 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
} }
// options that control what tests are run // options that control what tests are run
else if (this->CheckArgument(arg, "-I", "--tests-information") && else if (this->CheckArgument(arg, "-I"_s, "--tests-information") &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
this->GetTestHandler()->SetPersistentOption("TestsToRunInformation", this->GetTestHandler()->SetPersistentOption("TestsToRunInformation",
args[i].c_str()); args[i].c_str());
this->GetMemCheckHandler()->SetPersistentOption("TestsToRunInformation", this->GetMemCheckHandler()->SetPersistentOption("TestsToRunInformation",
args[i].c_str()); args[i].c_str());
} else if (this->CheckArgument(arg, "-U", "--union")) { } else if (this->CheckArgument(arg, "-U"_s, "--union")) {
this->GetTestHandler()->SetPersistentOption("UseUnion", "true"); this->GetTestHandler()->SetPersistentOption("UseUnion", "true");
this->GetMemCheckHandler()->SetPersistentOption("UseUnion", "true"); this->GetMemCheckHandler()->SetPersistentOption("UseUnion", "true");
} else if (this->CheckArgument(arg, "-R", "--tests-regex") && } else if (this->CheckArgument(arg, "-R"_s, "--tests-regex") &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
this->GetTestHandler()->SetPersistentOption("IncludeRegularExpression", this->GetTestHandler()->SetPersistentOption("IncludeRegularExpression",
args[i].c_str()); args[i].c_str());
this->GetMemCheckHandler()->SetPersistentOption("IncludeRegularExpression", this->GetMemCheckHandler()->SetPersistentOption("IncludeRegularExpression",
args[i].c_str()); args[i].c_str());
} else if (this->CheckArgument(arg, "-L", "--label-regex") && } else if (this->CheckArgument(arg, "-L"_s, "--label-regex") &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
this->GetTestHandler()->SetPersistentOption("LabelRegularExpression", this->GetTestHandler()->SetPersistentOption("LabelRegularExpression",
args[i].c_str()); args[i].c_str());
this->GetMemCheckHandler()->SetPersistentOption("LabelRegularExpression", this->GetMemCheckHandler()->SetPersistentOption("LabelRegularExpression",
args[i].c_str()); args[i].c_str());
} else if (this->CheckArgument(arg, "-LE", "--label-exclude") && } else if (this->CheckArgument(arg, "-LE"_s, "--label-exclude") &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
this->GetTestHandler()->SetPersistentOption( this->GetTestHandler()->SetPersistentOption(
@@ -2096,7 +2098,7 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
"ExcludeLabelRegularExpression", args[i].c_str()); "ExcludeLabelRegularExpression", args[i].c_str());
} }
else if (this->CheckArgument(arg, "-E", "--exclude-regex") && else if (this->CheckArgument(arg, "-E"_s, "--exclude-regex") &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
this->GetTestHandler()->SetPersistentOption("ExcludeRegularExpression", this->GetTestHandler()->SetPersistentOption("ExcludeRegularExpression",
@@ -2105,21 +2107,21 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
args[i].c_str()); args[i].c_str());
} }
else if (this->CheckArgument(arg, "-FA", "--fixture-exclude-any") && else if (this->CheckArgument(arg, "-FA"_s, "--fixture-exclude-any") &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
this->GetTestHandler()->SetPersistentOption( this->GetTestHandler()->SetPersistentOption(
"ExcludeFixtureRegularExpression", args[i].c_str()); "ExcludeFixtureRegularExpression", args[i].c_str());
this->GetMemCheckHandler()->SetPersistentOption( this->GetMemCheckHandler()->SetPersistentOption(
"ExcludeFixtureRegularExpression", args[i].c_str()); "ExcludeFixtureRegularExpression", args[i].c_str());
} else if (this->CheckArgument(arg, "-FS", "--fixture-exclude-setup") && } else if (this->CheckArgument(arg, "-FS"_s, "--fixture-exclude-setup") &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
this->GetTestHandler()->SetPersistentOption( this->GetTestHandler()->SetPersistentOption(
"ExcludeFixtureSetupRegularExpression", args[i].c_str()); "ExcludeFixtureSetupRegularExpression", args[i].c_str());
this->GetMemCheckHandler()->SetPersistentOption( this->GetMemCheckHandler()->SetPersistentOption(
"ExcludeFixtureSetupRegularExpression", args[i].c_str()); "ExcludeFixtureSetupRegularExpression", args[i].c_str());
} else if (this->CheckArgument(arg, "-FC", "--fixture-exclude-cleanup") && } else if (this->CheckArgument(arg, "-FC"_s, "--fixture-exclude-cleanup") &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
this->GetTestHandler()->SetPersistentOption( this->GetTestHandler()->SetPersistentOption(
@@ -2128,7 +2130,7 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
"ExcludeFixtureCleanupRegularExpression", args[i].c_str()); "ExcludeFixtureCleanupRegularExpression", args[i].c_str());
} }
else if (this->CheckArgument(arg, "--resource-spec-file") && else if (this->CheckArgument(arg, "--resource-spec-file"_s) &&
i < args.size() - 1) { i < args.size() - 1) {
i++; i++;
this->GetTestHandler()->SetPersistentOption("ResourceSpecFile", this->GetTestHandler()->SetPersistentOption("ResourceSpecFile",
@@ -2137,7 +2139,7 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
args[i].c_str()); args[i].c_str());
} }
else if (this->CheckArgument(arg, "--rerun-failed")) { else if (this->CheckArgument(arg, "--rerun-failed"_s)) {
this->GetTestHandler()->SetPersistentOption("RerunFailed", "true"); this->GetTestHandler()->SetPersistentOption("RerunFailed", "true");
this->GetMemCheckHandler()->SetPersistentOption("RerunFailed", "true"); this->GetMemCheckHandler()->SetPersistentOption("RerunFailed", "true");
} }
@@ -2189,7 +2191,7 @@ void cmCTest::HandleScriptArguments(size_t& i, std::vector<std::string>& args,
bool& SRArgumentSpecified) bool& SRArgumentSpecified)
{ {
std::string arg = args[i]; std::string arg = args[i];
if (this->CheckArgument(arg, "-SP", "--script-new-process") && if (this->CheckArgument(arg, "-SP"_s, "--script-new-process") &&
i < args.size() - 1) { i < args.size() - 1) {
this->Impl->RunConfigurationScript = true; this->Impl->RunConfigurationScript = true;
i++; i++;
@@ -2200,7 +2202,8 @@ void cmCTest::HandleScriptArguments(size_t& i, std::vector<std::string>& args,
} }
} }
if (this->CheckArgument(arg, "-SR", "--script-run") && i < args.size() - 1) { if (this->CheckArgument(arg, "-SR"_s, "--script-run") &&
i < args.size() - 1) {
SRArgumentSpecified = true; SRArgumentSpecified = true;
this->Impl->RunConfigurationScript = true; this->Impl->RunConfigurationScript = true;
i++; i++;
@@ -2208,7 +2211,7 @@ void cmCTest::HandleScriptArguments(size_t& i, std::vector<std::string>& args,
ch->AddConfigurationScript(args[i].c_str(), true); ch->AddConfigurationScript(args[i].c_str(), true);
} }
if (this->CheckArgument(arg, "-S", "--script") && i < args.size() - 1) { if (this->CheckArgument(arg, "-S"_s, "--script") && i < args.size() - 1) {
this->Impl->RunConfigurationScript = true; this->Impl->RunConfigurationScript = true;
i++; i++;
cmCTestScriptHandler* ch = this->GetScriptHandler(); cmCTestScriptHandler* ch = this->GetScriptHandler();
@@ -2258,7 +2261,8 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
// --dashboard: handle a request for a dashboard // --dashboard: handle a request for a dashboard
std::string arg = args[i]; std::string arg = args[i];
if (this->CheckArgument(arg, "-D", "--dashboard") && i < args.size() - 1) { if (this->CheckArgument(arg, "-D"_s, "--dashboard") &&
i < args.size() - 1) {
this->Impl->ProduceXML = true; this->Impl->ProduceXML = true;
i++; i++;
std::string targ = args[i]; std::string targ = args[i];
@@ -2294,7 +2298,7 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
} }
// --extra-submit // --extra-submit
if (this->CheckArgument(arg, "--extra-submit") && i < args.size() - 1) { if (this->CheckArgument(arg, "--extra-submit"_s) && i < args.size() - 1) {
this->Impl->ProduceXML = true; this->Impl->ProduceXML = true;
this->SetTest("Submit"); this->SetTest("Submit");
i++; i++;
@@ -2304,12 +2308,13 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
} }
// --build-and-test options // --build-and-test options
if (this->CheckArgument(arg, "--build-and-test") && i < args.size() - 1) { if (this->CheckArgument(arg, "--build-and-test"_s) &&
i < args.size() - 1) {
cmakeAndTest = true; cmakeAndTest = true;
} }
// --schedule-random // --schedule-random
if (this->CheckArgument(arg, "--schedule-random")) { if (this->CheckArgument(arg, "--schedule-random"_s)) {
this->Impl->ScheduleType = "Random"; this->Impl->ScheduleType = "Random";
} }
@@ -2364,7 +2369,7 @@ bool cmCTest::HandleTestActionArgument(const char* ctestExec, size_t& i,
{ {
bool success = true; bool success = true;
std::string arg = args[i]; std::string arg = args[i];
if (this->CheckArgument(arg, "-T", "--test-action") && if (this->CheckArgument(arg, "-T"_s, "--test-action") &&
(i < args.size() - 1)) { (i < args.size() - 1)) {
this->Impl->ProduceXML = true; this->Impl->ProduceXML = true;
i++; i++;
@@ -2396,15 +2401,15 @@ bool cmCTest::HandleTestModelArgument(const char* ctestExec, size_t& i,
{ {
bool success = true; bool success = true;
std::string arg = args[i]; std::string arg = args[i];
if (this->CheckArgument(arg, "-M", "--test-model") && if (this->CheckArgument(arg, "-M"_s, "--test-model") &&
(i < args.size() - 1)) { (i < args.size() - 1)) {
i++; i++;
std::string const& str = args[i]; std::string const& str = args[i];
if (cmSystemTools::LowerCase(str) == "nightly") { if (cmSystemTools::LowerCase(str) == "nightly"_s) {
this->SetTestModel(cmCTest::NIGHTLY); this->SetTestModel(cmCTest::NIGHTLY);
} else if (cmSystemTools::LowerCase(str) == "continuous") { } else if (cmSystemTools::LowerCase(str) == "continuous"_s) {
this->SetTestModel(cmCTest::CONTINUOUS); this->SetTestModel(cmCTest::CONTINUOUS);
} else if (cmSystemTools::LowerCase(str) == "experimental") { } else if (cmSystemTools::LowerCase(str) == "experimental"_s) {
this->SetTestModel(cmCTest::EXPERIMENTAL); this->SetTestModel(cmCTest::EXPERIMENTAL);
} else { } else {
success = false; success = false;
@@ -2722,7 +2727,7 @@ std::string cmCTest::GetSubmitURL()
std::string site = this->GetCTestConfiguration("DropSite"); std::string site = this->GetCTestConfiguration("DropSite");
std::string location = this->GetCTestConfiguration("DropLocation"); std::string location = this->GetCTestConfiguration("DropLocation");
url = cmStrCat(method.empty() ? "http" : method, "://"); url = cmStrCat(method.empty() ? "http" : method, "://"_s);
if (!user.empty()) { if (!user.empty()) {
url += user; url += user;
if (!password.empty()) { if (!password.empty()) {

6
Source/cmCTest.h
View File

@@ -13,6 +13,8 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include <cm/string_view>
#include "cmDuration.h" #include "cmDuration.h"
#include "cmProcessOutput.h" #include "cmProcessOutput.h"
@@ -507,8 +509,8 @@ private:
std::vector<std::string> const& files); std::vector<std::string> const& files);
/** Check if the argument is the one specified */ /** Check if the argument is the one specified */
bool CheckArgument(const std::string& arg, const char* varg1, static bool CheckArgument(const std::string& arg, cm::string_view varg1,
const char* varg2 = nullptr); const char* varg2 = nullptr);
/** Output errors from a test */ /** Output errors from a test */
void OutputTestErrors(std::vector<char> const& process_output); void OutputTestErrors(std::vector<char> const& process_output);

27
Source/cmake.cxx
View File

@@ -24,6 +24,7 @@
#include "cmsys/Glob.hxx" #include "cmsys/Glob.hxx"
#include "cmsys/RegularExpression.hxx" #include "cmsys/RegularExpression.hxx"
#include "cm_static_string_view.hxx"
#include "cm_sys_stat.h" #include "cm_sys_stat.h"
#include "cmAlgorithms.h" #include "cmAlgorithms.h"
@@ -524,11 +525,11 @@ bool cmake::FindPackage(const std::vector<std::string>& args)
if (!quiet) { if (!quiet) {
printf("%s not found.\n", packageName.c_str()); printf("%s not found.\n", packageName.c_str());
} }
} else if (mode == "EXIST") { } else if (mode == "EXIST"_s) {
if (!quiet) { if (!quiet) {
printf("%s found.\n", packageName.c_str()); printf("%s found.\n", packageName.c_str());
} }
} else if (mode == "COMPILE") { } else if (mode == "COMPILE"_s) {
std::string includes = mf->GetSafeDefinition("PACKAGE_INCLUDE_DIRS"); std::string includes = mf->GetSafeDefinition("PACKAGE_INCLUDE_DIRS");
std::vector<std::string> includeDirs = cmExpandedList(includes); std::vector<std::string> includeDirs = cmExpandedList(includes);
@@ -539,7 +540,7 @@ bool cmake::FindPackage(const std::vector<std::string>& args)
std::string definitions = mf->GetSafeDefinition("PACKAGE_DEFINITIONS"); std::string definitions = mf->GetSafeDefinition("PACKAGE_DEFINITIONS");
printf("%s %s\n", includeFlags.c_str(), definitions.c_str()); printf("%s %s\n", includeFlags.c_str(), definitions.c_str());
} else if (mode == "LINK") { } else if (mode == "LINK"_s) {
const char* targetName = "dummy"; const char* targetName = "dummy";
std::vector<std::string> srcs; std::vector<std::string> srcs;
cmTarget* tgt = mf->AddExecutable(targetName, srcs, true); cmTarget* tgt = mf->AddExecutable(targetName, srcs, true);
@@ -671,7 +672,7 @@ void cmake::SetArgs(const std::vector<std::string>& args)
} else if ((i < args.size() - 1) && } else if ((i < args.size() - 1) &&
cmHasLiteralPrefix(arg, "--check-stamp-list")) { cmHasLiteralPrefix(arg, "--check-stamp-list")) {
this->CheckStampList = args[++i]; this->CheckStampList = args[++i];
} else if (arg == "--regenerate-during-build") { } else if (arg == "--regenerate-during-build"_s) {
this->RegenerateDuringBuild = true; this->RegenerateDuringBuild = true;
} }
#if defined(CMAKE_HAVE_VS_GENERATORS) #if defined(CMAKE_HAVE_VS_GENERATORS)
@@ -745,7 +746,7 @@ void cmake::SetArgs(const std::vector<std::string>& args)
} }
this->SetLogLevel(logLevel); this->SetLogLevel(logLevel);
this->LogLevelWasSetViaCLI = true; this->LogLevelWasSetViaCLI = true;
} else if (arg == "--log-context") { } else if (arg == "--log-context"_s) {
this->SetShowLogContext(true); this->SetShowLogContext(true);
} else if (cmHasLiteralPrefix(arg, "--debug-find")) { } else if (cmHasLiteralPrefix(arg, "--debug-find")) {
std::cout << "Running with debug output on for the `find` commands.\n"; std::cout << "Running with debug output on for the `find` commands.\n";
@@ -886,7 +887,7 @@ void cmake::SetArgs(const std::vector<std::string>& args)
"--profiling-format specified but no --profiling-output!"); "--profiling-format specified but no --profiling-output!");
return; return;
} }
if (profilingFormat == "google-trace") { if (profilingFormat == "google-trace"_s) {
try { try {
this->ProfilingOutput = this->ProfilingOutput =
cm::make_unique<cmMakefileProfilingData>(profilingOutput); cm::make_unique<cmMakefileProfilingData>(profilingOutput);
@@ -1037,9 +1038,9 @@ void cmake::SetDirectoriesFromFile(const std::string& arg)
std::string fullPath = cmSystemTools::CollapseFullPath(arg); std::string fullPath = cmSystemTools::CollapseFullPath(arg);
std::string name = cmSystemTools::GetFilenameName(fullPath); std::string name = cmSystemTools::GetFilenameName(fullPath);
name = cmSystemTools::LowerCase(name); name = cmSystemTools::LowerCase(name);
if (name == "cmakecache.txt") { if (name == "cmakecache.txt"_s) {
cachePath = cmSystemTools::GetFilenamePath(fullPath); cachePath = cmSystemTools::GetFilenamePath(fullPath);
} else if (name == "cmakelists.txt") { } else if (name == "cmakelists.txt"_s) {
listPath = cmSystemTools::GetFilenamePath(fullPath); listPath = cmSystemTools::GetFilenamePath(fullPath);
} }
} else { } else {
@@ -1048,7 +1049,7 @@ void cmake::SetDirectoriesFromFile(const std::string& arg)
std::string fullPath = cmSystemTools::CollapseFullPath(arg); std::string fullPath = cmSystemTools::CollapseFullPath(arg);
std::string name = cmSystemTools::GetFilenameName(fullPath); std::string name = cmSystemTools::GetFilenameName(fullPath);
name = cmSystemTools::LowerCase(name); name = cmSystemTools::LowerCase(name);
if (name == "cmakecache.txt" || name == "cmakelists.txt") { if (name == "cmakecache.txt"_s || name == "cmakelists.txt"_s) {
argIsFile = true; argIsFile = true;
listPath = cmSystemTools::GetFilenamePath(fullPath); listPath = cmSystemTools::GetFilenamePath(fullPath);
} else { } else {
@@ -1936,13 +1937,13 @@ void cmake::AddCacheEntry(const std::string& key, const char* value,
cmStateEnums::CacheEntryType(type)); cmStateEnums::CacheEntryType(type));
this->UnwatchUnusedCli(key); this->UnwatchUnusedCli(key);
if (key == "CMAKE_WARN_DEPRECATED") { if (key == "CMAKE_WARN_DEPRECATED"_s) {
this->Messenger->SetSuppressDeprecatedWarnings(value && cmIsOff(value)); this->Messenger->SetSuppressDeprecatedWarnings(value && cmIsOff(value));
} else if (key == "CMAKE_ERROR_DEPRECATED") { } else if (key == "CMAKE_ERROR_DEPRECATED"_s) {
this->Messenger->SetDeprecatedWarningsAsErrors(cmIsOn(value)); this->Messenger->SetDeprecatedWarningsAsErrors(cmIsOn(value));
} else if (key == "CMAKE_SUPPRESS_DEVELOPER_WARNINGS") { } else if (key == "CMAKE_SUPPRESS_DEVELOPER_WARNINGS"_s) {
this->Messenger->SetSuppressDevWarnings(cmIsOn(value)); this->Messenger->SetSuppressDevWarnings(cmIsOn(value));
} else if (key == "CMAKE_SUPPRESS_DEVELOPER_ERRORS") { } else if (key == "CMAKE_SUPPRESS_DEVELOPER_ERRORS"_s) {
this->Messenger->SetDevWarningsAsErrors(value && cmIsOff(value)); this->Messenger->SetDevWarningsAsErrors(value && cmIsOff(value));
} }
} }