Commit b1f87a50 authored by Dāvis Mosāns's avatar Dāvis Mosāns Committed by Brad King
Browse files

Use better KWSys SystemTools::GetEnv and HasEnv signatures

parent 03407040
......@@ -1074,11 +1074,11 @@ const char* cmCPackGenerator::GetInstallPath()
return this->InstallPath.c_str();
}
#if defined(_WIN32) && !defined(__CYGWIN__)
const char* prgfiles = cmsys::SystemTools::GetEnv("ProgramFiles");
const char* sysDrive = cmsys::SystemTools::GetEnv("SystemDrive");
if (prgfiles) {
std::string prgfiles;
std::string sysDrive;
if (cmsys::SystemTools::GetEnv("ProgramFiles", prgfiles)) {
this->InstallPath = prgfiles;
} else if (sysDrive) {
} else if (cmsys::SystemTools::GetEnv("SystemDrive", sysDrive)) {
this->InstallPath = sysDrive;
this->InstallPath += "/Program Files";
} else {
......
......@@ -727,10 +727,8 @@ int cmCTestCoverageHandler::HandleCoberturaCoverage(
// if it doesn't exist or is empty, assume the
// binary directory is used.
std::string coverageXMLFile;
const char* covDir = cmSystemTools::GetEnv("COBERTURADIR");
if (covDir && strlen(covDir) != 0) {
coverageXMLFile = std::string(covDir);
} else {
if (!cmSystemTools::GetEnv("COBERTURADIR", coverageXMLFile) ||
coverageXMLFile.empty()) {
coverageXMLFile = this->CTest->GetBinaryDir();
}
// build the find file string with the directory from above
......@@ -791,7 +789,8 @@ struct cmCTestCoverageHandlerLocale
{
cmCTestCoverageHandlerLocale()
{
if (const char* l = cmSystemTools::GetEnv("LC_ALL")) {
std::string l;
if (cmSystemTools::GetEnv("LC_ALL", l)) {
lc_all = l;
}
if (lc_all != "C") {
......@@ -2121,8 +2120,8 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary(
int cmCTestCoverageHandler::HandleBullseyeCoverage(
cmCTestCoverageHandlerContainer* cont)
{
const char* covfile = cmSystemTools::GetEnv("COVFILE");
if (!covfile || strlen(covfile) == 0) {
std::string covfile;
if (!cmSystemTools::GetEnv("COVFILE", covfile) || covfile.empty()) {
cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
" COVFILE environment variable not found, not running "
" bullseye\n",
......
......@@ -219,16 +219,18 @@ bool cmCTestCurl::HttpRequest(std::string const& url,
void cmCTestCurl::SetProxyType()
{
if (cmSystemTools::GetEnv("HTTP_PROXY")) {
this->HTTPProxy = cmSystemTools::GetEnv("HTTP_PROXY");
if (cmSystemTools::GetEnv("HTTP_PROXY_PORT")) {
this->HTTPProxy = "";
// this is the default
this->HTTPProxyType = CURLPROXY_HTTP;
this->HTTPProxyAuth = "";
if (cmSystemTools::GetEnv("HTTP_PROXY", this->HTTPProxy)) {
std::string port;
if (cmSystemTools::GetEnv("HTTP_PROXY_PORT", port)) {
this->HTTPProxy += ":";
this->HTTPProxy += cmSystemTools::GetEnv("HTTP_PROXY_PORT");
this->HTTPProxy += port;
}
if (cmSystemTools::GetEnv("HTTP_PROXY_TYPE")) {
// this is the default
this->HTTPProxyType = CURLPROXY_HTTP;
std::string type = cmSystemTools::GetEnv("HTTP_PROXY_TYPE");
std::string type;
if (cmSystemTools::GetEnv("HTTP_PROXY_TYPE", type)) {
// HTTP/SOCKS4/SOCKS5
if (type == "HTTP") {
this->HTTPProxyType = CURLPROXY_HTTP;
......@@ -238,12 +240,11 @@ void cmCTestCurl::SetProxyType()
this->HTTPProxyType = CURLPROXY_SOCKS5;
}
}
if (cmSystemTools::GetEnv("HTTP_PROXY_USER")) {
this->HTTPProxyAuth = cmSystemTools::GetEnv("HTTP_PROXY_USER");
}
if (cmSystemTools::GetEnv("HTTP_PROXY_PASSWD")) {
cmSystemTools::GetEnv("HTTP_PROXY_USER", this->HTTPProxyAuth);
std::string passwd;
if (cmSystemTools::GetEnv("HTTP_PROXY_PASSWD", passwd)) {
this->HTTPProxyAuth += ":";
this->HTTPProxyAuth += cmSystemTools::GetEnv("HTTP_PROXY_PASSWD");
this->HTTPProxyAuth += passwd;
}
}
}
......@@ -261,12 +261,14 @@ void cmCTestMultiProcessHandler::StartNextTests()
allTestsFailedTestLoadCheck = true;
// Check for a fake load average value used in testing.
if (const char* fake_load_value =
cmSystemTools::GetEnv("__CTEST_FAKE_LOAD_AVERAGE_FOR_TESTING")) {
std::string fake_load_value;
if (cmSystemTools::GetEnv("__CTEST_FAKE_LOAD_AVERAGE_FOR_TESTING",
fake_load_value)) {
usedFakeLoadForTesting = true;
if (!cmSystemTools::StringToULong(fake_load_value, &systemLoad)) {
if (!cmSystemTools::StringToULong(fake_load_value.c_str(),
&systemLoad)) {
cmSystemTools::Error("Failed to parse fake load value: ",
fake_load_value);
fake_load_value.c_str());
}
}
// If it's not set, look up the true load average.
......
......@@ -36,8 +36,8 @@ bool cmBuildCommand::MainSignature(std::vector<std::string> const& args)
const char* variable = args[0].c_str();
// Parse remaining arguments.
const char* configuration = CM_NULLPTR;
const char* project_name = CM_NULLPTR;
std::string configuration;
std::string project_name;
std::string target;
enum Doing
{
......@@ -56,10 +56,10 @@ bool cmBuildCommand::MainSignature(std::vector<std::string> const& args)
doing = DoingTarget;
} else if (doing == DoingConfiguration) {
doing = DoingNone;
configuration = args[i].c_str();
configuration = args[i];
} else if (doing == DoingProjectName) {
doing = DoingNone;
project_name = args[i].c_str();
project_name = args[i];
} else if (doing == DoingTarget) {
doing = DoingNone;
target = args[i];
......@@ -76,14 +76,14 @@ bool cmBuildCommand::MainSignature(std::vector<std::string> const& args)
// so we put this code here to end up with the same default configuration
// as the original 2-arg build_command signature:
//
if (!configuration || !*configuration) {
configuration = getenv("CMAKE_CONFIG_TYPE");
if (configuration.empty()) {
cmSystemTools::GetEnv("CMAKE_CONFIG_TYPE", configuration);
}
if (!configuration || !*configuration) {
if (configuration.empty()) {
configuration = "Release";
}
if (project_name && *project_name) {
if (!project_name.empty()) {
this->Makefile->IssueMessage(
cmake::AUTHOR_WARNING,
"Ignoring PROJECT_NAME option because it has no effect.");
......@@ -91,7 +91,8 @@ bool cmBuildCommand::MainSignature(std::vector<std::string> const& args)
std::string makecommand =
this->Makefile->GetGlobalGenerator()->GenerateCMakeBuildCommand(
target, configuration, "", this->Makefile->IgnoreErrorsCMP0061());
target, configuration.c_str(), "",
this->Makefile->IgnoreErrorsCMP0061());
this->Makefile->AddDefinition(variable, makecommand.c_str());
......@@ -108,10 +109,10 @@ bool cmBuildCommand::TwoArgsSignature(std::vector<std::string> const& args)
const char* define = args[0].c_str();
const char* cacheValue = this->Makefile->GetDefinition(define);
std::string configType = "Release";
const char* cfg = getenv("CMAKE_CONFIG_TYPE");
if (cfg && *cfg) {
configType = cfg;
std::string configType;
if (!cmSystemTools::GetEnv("CMAKE_CONFIG_TYPE", configType) ||
configType.empty()) {
configType = "Release";
}
std::string makecommand =
......
......@@ -31,8 +31,9 @@ cmCLocaleEnvironmentScope::cmCLocaleEnvironmentScope()
std::string cmCLocaleEnvironmentScope::GetEnv(std::string const& key)
{
const char* value = cmSystemTools::GetEnv(key);
return value ? value : std::string();
std::string value;
cmSystemTools::GetEnv(key, value);
return value;
}
void cmCLocaleEnvironmentScope::SetEnv(std::string const& key,
......
......@@ -298,9 +298,10 @@ cmCTest::cmCTest()
this->ComputedCompressMemCheckOutput = false;
this->RepeatTests = 1; // default to run each test once
this->RepeatUntilFail = false;
if (const char* outOnFail =
cmSystemTools::GetEnv("CTEST_OUTPUT_ON_FAILURE")) {
this->OutputTestOutputOnTestFailure = !cmSystemTools::IsOff(outOnFail);
std::string outOnFail;
if (cmSystemTools::GetEnv("CTEST_OUTPUT_ON_FAILURE", outOnFail)) {
this->OutputTestOutputOnTestFailure =
!cmSystemTools::IsOff(outOnFail.c_str());
}
this->InitStreams();
......@@ -2091,8 +2092,9 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
// handle CTEST_PARALLEL_LEVEL environment variable
if (!this->ParallelLevelSetInCli) {
if (const char* parallel = cmSystemTools::GetEnv("CTEST_PARALLEL_LEVEL")) {
int plevel = atoi(parallel);
std::string parallel;
if (cmSystemTools::GetEnv("CTEST_PARALLEL_LEVEL", parallel)) {
int plevel = atoi(parallel.c_str());
this->SetParallelLevel(plevel);
}
}
......
......@@ -71,12 +71,12 @@ char* cmCommandArgumentParserHelper::ExpandSpecialVariable(const char* key,
return this->EmptyVariable;
}
if (strcmp(key, "ENV") == 0) {
char* ptr = getenv(var);
if (ptr) {
std::string str;
if (cmSystemTools::GetEnv(var, str)) {
if (this->EscapeQuotes) {
return this->AddString(cmSystemTools::EscapeQuotes(ptr));
return this->AddString(cmSystemTools::EscapeQuotes(str.c_str()));
} else {
return ptr;
return this->AddString(str);
}
}
return this->EmptyVariable;
......
......@@ -486,7 +486,7 @@ bool cmConditionEvaluator::HandleLevel1(cmArgumentList& newArgs, std::string&,
if (argP1len > 4 && argP1->GetValue().substr(0, 4) == "ENV{" &&
argP1->GetValue().operator[](argP1len - 1) == '}') {
std::string env = argP1->GetValue().substr(4, argP1len - 5);
bdef = cmSystemTools::GetEnv(env.c_str()) ? true : false;
bdef = cmSystemTools::HasEnv(env.c_str());
} else {
bdef = this->Makefile.IsDefinitionSet(argP1->GetValue());
}
......
......@@ -327,11 +327,10 @@ void cmExportCommand::StorePackageRegistryDir(std::string const& package,
fname += "/cmake/packages/";
fname += package;
#else
const char* home = cmSystemTools::GetEnv("HOME");
if (!home) {
std::string fname;
if (!cmSystemTools::GetEnv("HOME", fname)) {
return;
}
std::string fname = home;
cmSystemTools::ConvertToUnixSlashes(fname);
fname += "/.cmake/packages/";
fname += package;
......
......@@ -208,7 +208,8 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(std::ostream& out,
// get the variables from the environment and from the cache and then
// figure out which one to use:
const char* envVarValue = getenv(envVar);
std::string envVarValue;
const bool envVarSet = cmSystemTools::GetEnv(envVar, envVarValue);
std::string cacheEntryName = "CMAKE_ECLIPSE_ENVVAR_";
cacheEntryName += envVar;
......@@ -217,17 +218,17 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(std::ostream& out,
// now we have both, decide which one to use
std::string valueToUse;
if (envVarValue == CM_NULLPTR && cacheValue == CM_NULLPTR) {
if (!envVarSet && cacheValue == CM_NULLPTR) {
// nothing known, do nothing
valueToUse = "";
} else if (envVarValue != CM_NULLPTR && cacheValue == CM_NULLPTR) {
} else if (envVarSet && cacheValue == CM_NULLPTR) {
// The variable is in the env, but not in the cache. Use it and put it
// in the cache
valueToUse = envVarValue;
mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(),
cacheEntryName.c_str(), cmState::STRING, true);
mf->GetCMakeInstance()->SaveCache(lg->GetBinaryDirectory());
} else if (envVarValue == CM_NULLPTR && cacheValue != CM_NULLPTR) {
} else if (!envVarSet && cacheValue != CM_NULLPTR) {
// It is already in the cache, but not in the env, so use it from the cache
valueToUse = cacheValue;
} else {
......
......@@ -1609,8 +1609,10 @@ struct cmFileInstaller : public cmFileCopier
// Installation does not use source permissions by default.
this->UseSourcePermissions = false;
// Check whether to copy files always or only if they have changed.
this->Always =
cmSystemTools::IsOn(cmSystemTools::GetEnv("CMAKE_INSTALL_ALWAYS"));
std::string install_always;
if (cmSystemTools::GetEnv("CMAKE_INSTALL_ALWAYS", install_always)) {
this->Always = cmSystemTools::IsOn(install_always.c_str());
}
// Get the current manifest.
this->Manifest =
this->Makefile->GetSafeDefinition("CMAKE_INSTALL_MANIFEST_FILES");
......@@ -1869,9 +1871,8 @@ bool cmFileInstaller::HandleInstallDestination()
return false;
}
const char* destdir = cmSystemTools::GetEnv("DESTDIR");
if (destdir && *destdir) {
std::string sdestdir = destdir;
std::string sdestdir;
if (cmSystemTools::GetEnv("DESTDIR", sdestdir) && !sdestdir.empty()) {
cmSystemTools::ConvertToUnixSlashes(sdestdir);
char ch1 = destination[0];
char ch2 = destination[1];
......
......@@ -1077,8 +1077,8 @@ void cmFindPackageCommand::FillPrefixesUserRegistry()
this->LabeledPaths[PathLabel::UserRegistry]);
}
#else
if (const char* home = cmSystemTools::GetEnv("HOME")) {
std::string dir = home;
std::string dir;
if (cmSystemTools::GetEnv("HOME", dir)) {
dir += "/.cmake/packages/";
dir += this->Name;
this->LoadPackageRegistryDir(dir,
......
......@@ -122,9 +122,9 @@ void cmGlobalVisualStudio7Generator::EnableLanguage(
// does not use the environment it is run in, and this allows
// for running commands and using dll's that the IDE environment
// does not know about.
const char* extraPath = cmSystemTools::GetEnv("CMAKE_MSVCIDE_RUN_PATH");
if (extraPath) {
mf->AddCacheDefinition("CMAKE_MSVCIDE_RUN_PATH", extraPath,
std::string extraPath;
if (cmSystemTools::GetEnv("CMAKE_MSVCIDE_RUN_PATH", extraPath)) {
mf->AddCacheDefinition("CMAKE_MSVCIDE_RUN_PATH", extraPath.c_str(),
"Saved environment variable CMAKE_MSVCIDE_RUN_PATH",
cmState::STATIC);
}
......
......@@ -2572,6 +2572,7 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
std::string const& lookup = result.substr(var.loc);
const char* value = CM_NULLPTR;
std::string varresult;
std::string svalue;
static const std::string lineVar = "CMAKE_CURRENT_LIST_LINE";
switch (var.domain) {
case NORMAL:
......@@ -2584,7 +2585,9 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
}
break;
case ENVIRONMENT:
value = cmSystemTools::GetEnv(lookup.c_str());
if (cmSystemTools::GetEnv(lookup, svalue)) {
value = svalue.c_str();
}
break;
case CACHE:
value = state->GetCacheEntryValue(lookup);
......
......@@ -741,5 +741,5 @@ bool cmNinjaTargetGenerator::ForceResponseFile()
{
static std::string const forceRspFile = "CMAKE_NINJA_FORCE_RESPONSE_FILE";
return (this->GetMakefile()->IsDefinitionSet(forceRspFile) ||
cmSystemTools::GetEnv(forceRspFile) != CM_NULLPTR);
cmSystemTools::HasEnv(forceRspFile));
}
......@@ -88,7 +88,7 @@ static std::string extractSubDir(const std::string& absPath,
}
cmQtAutoGenerators::cmQtAutoGenerators()
: Verbose(cmsys::SystemTools::GetEnv("VERBOSE") != CM_NULLPTR)
: Verbose(cmsys::SystemTools::HasEnv("VERBOSE"))
, ColorOutput(true)
, RunMocFailed(false)
, RunUicFailed(false)
......
......@@ -31,13 +31,14 @@ bool cmSetCommand::InitialPass(std::vector<std::string> const& args,
putEnvArg += "=";
// what is the current value if any
const char* currValue = getenv(varName);
std::string currValue;
const bool currValueSet = cmSystemTools::GetEnv(varName, currValue);
delete[] varName;
// will it be set to something, then set it
if (args.size() > 1 && !args[1].empty()) {
// but only if it is different from current value
if (!currValue || strcmp(currValue, args[1].c_str())) {
if (!currValueSet || currValue != args[1]) {
putEnvArg += args[1];
cmSystemTools::PutEnv(putEnvArg);
}
......@@ -45,7 +46,7 @@ bool cmSetCommand::InitialPass(std::vector<std::string> const& args,
}
// if it will be cleared, then clear it if it isn't already clear
if (currValue) {
if (currValueSet) {
cmSystemTools::PutEnv(putEnvArg);
}
return true;
......
......@@ -1286,8 +1286,9 @@ void cmState::Snapshot::SetDefaultDefinitions()
this->SetDefinition("CMAKE_HOST_UNIX", "1");
#endif
#if defined(__CYGWIN__)
if (cmSystemTools::IsOn(
cmSystemTools::GetEnv("CMAKE_LEGACY_CYGWIN_WIN32"))) {
std::string legacy;
if (cmSystemTools::GetEnv("CMAKE_LEGACY_CYGWIN_WIN32", legacy) &&
cmSystemTools::IsOn(legacy.c_str())) {
this->SetDefinition("WIN32", "1");
this->SetDefinition("CMAKE_HOST_WIN32", "1");
}
......
......@@ -2069,9 +2069,9 @@ void cmSystemTools::MakefileColorEcho(int color, const char* message,
// However, we can test for some situations when the answer is most
// likely no.
int assumeTTY = cmsysTerminal_Color_AssumeTTY;
if (cmSystemTools::GetEnv("DART_TEST_FROM_DART") ||
cmSystemTools::GetEnv("DASHBOARD_TEST_FROM_CTEST") ||
cmSystemTools::GetEnv("CTEST_INTERACTIVE_DEBUG_MODE")) {
if (cmSystemTools::HasEnv("DART_TEST_FROM_DART") ||
cmSystemTools::HasEnv("DASHBOARD_TEST_FROM_CTEST") ||
cmSystemTools::HasEnv("CTEST_INTERACTIVE_DEBUG_MODE")) {
// Avoid printing color escapes during dashboard builds.
assumeTTY = 0;
}
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment