--- Source/CPack/cmCPackGenerator.cxx | 8 +++--- Source/CTest/cmCTestCoverageHandler.cxx | 12 ++++----- Source/CTest/cmCTestCurl.cxx | 27 ++++++++++---------- Source/CTest/cmCTestMultiProcessHandler.cxx | 8 +++--- Source/cmBuildCommand.cxx | 25 +++++++++---------- Source/cmCLocaleEnvironmentScope.cxx | 5 ++-- Source/cmCTest.cxx | 11 +++++---- Source/cmCommandArgumentParserHelper.cxx | 8 +++--- Source/cmConditionEvaluator.cxx | 2 +- Source/cmExportCommand.cxx | 5 ++-- Source/cmExtraEclipseCDT4Generator.cxx | 9 ++++--- Source/cmFileCommand.cxx | 11 +++++---- Source/cmFindPackageCommand.cxx | 4 +-- Source/cmGlobalVisualStudio7Generator.cxx | 6 ++--- Source/cmMakefile.cxx | 5 +++- Source/cmNinjaTargetGenerator.cxx | 2 +- Source/cmQtAutoGenerators.cxx | 2 +- Source/cmSetCommand.cxx | 7 +++--- Source/cmState.cxx | 5 ++-- Source/cmSystemTools.cxx | 6 ++--- Source/cmTimestamp.cxx | 7 +++--- Source/cmUtils.hxx | 26 ++++++++++++++++++++ Source/cmake.cxx | 21 +++++----------- Source/cmcmd.cxx | 16 +++++------- Source/kwsys/SystemInformation.cxx | 20 +++++++-------- Source/kwsys/SystemTools.cxx | 38 +++++++++++------------------ Source/kwsys/testSystemTools.cxx | 9 ++++--- 27 files changed, 156 insertions(+), 149 deletions(-) create mode 100644 Source/cmUtils.hxx
diff --git a/Source/CPack/cmCPackGenerator.cxx b/Source/CPack/cmCPackGenerator.cxx index df8bb0f..76609e1 100644 --- a/Source/CPack/cmCPackGenerator.cxx +++ b/Source/CPack/cmCPackGenerator.cxx @@ -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 { diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx index 7102533..9410a52 100644 --- a/Source/CTest/cmCTestCoverageHandler.cxx +++ b/Source/CTest/cmCTestCoverageHandler.cxx @@ -727,10 +727,7 @@ 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 +788,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 +2119,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", diff --git a/Source/CTest/cmCTestCurl.cxx b/Source/CTest/cmCTestCurl.cxx index 6b8e5b5..b335e32 100644 --- a/Source/CTest/cmCTestCurl.cxx +++ b/Source/CTest/cmCTestCurl.cxx @@ -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; } } } diff --git a/Source/CTest/cmCTestMultiProcessHandler.cxx b/Source/CTest/cmCTestMultiProcessHandler.cxx index ae97d32..ffd51c7 100644 --- a/Source/CTest/cmCTestMultiProcessHandler.cxx +++ b/Source/CTest/cmCTestMultiProcessHandler.cxx @@ -261,12 +261,12 @@ 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. diff --git a/Source/cmBuildCommand.cxx b/Source/cmBuildCommand.cxx index fb143a2..3dfd9cf 100644 --- a/Source/cmBuildCommand.cxx +++ b/Source/cmBuildCommand.cxx @@ -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,7 @@ 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 +108,9 @@ 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 = diff --git a/Source/cmCLocaleEnvironmentScope.cxx b/Source/cmCLocaleEnvironmentScope.cxx index a19dbae..e4c74ec 100644 --- a/Source/cmCLocaleEnvironmentScope.cxx +++ b/Source/cmCLocaleEnvironmentScope.cxx @@ -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, diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx index 3bb997a..05dd245 100644 --- a/Source/cmCTest.cxx +++ b/Source/cmCTest.cxx @@ -298,9 +298,9 @@ 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 +2091,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); } } diff --git a/Source/cmCommandArgumentParserHelper.cxx b/Source/cmCommandArgumentParserHelper.cxx index 294117c..42fb105 100644 --- a/Source/cmCommandArgumentParserHelper.cxx +++ b/Source/cmCommandArgumentParserHelper.cxx @@ -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; diff --git a/Source/cmConditionEvaluator.cxx b/Source/cmConditionEvaluator.cxx index 67b2571..e02221c 100644 --- a/Source/cmConditionEvaluator.cxx +++ b/Source/cmConditionEvaluator.cxx @@ -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()); } diff --git a/Source/cmExportCommand.cxx b/Source/cmExportCommand.cxx index 3cb575e..fc62492 100644 --- a/Source/cmExportCommand.cxx +++ b/Source/cmExportCommand.cxx @@ -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; diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx index 16cb082..93c55cc 100644 --- a/Source/cmExtraEclipseCDT4Generator.cxx +++ b/Source/cmExtraEclipseCDT4Generator.cxx @@ -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 { diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx index 5a1238b..835b118 100644 --- a/Source/cmFileCommand.cxx +++ b/Source/cmFileCommand.cxx @@ -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]; diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx index d5fd75d..260079b 100644 --- a/Source/cmFindPackageCommand.cxx +++ b/Source/cmFindPackageCommand.cxx @@ -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, diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx index 262909f..0a83b3a 100644 --- a/Source/cmGlobalVisualStudio7Generator.cxx +++ b/Source/cmGlobalVisualStudio7Generator.cxx @@ -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); } diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx index 0d550dd..ab7de57 100644 --- a/Source/cmMakefile.cxx +++ b/Source/cmMakefile.cxx @@ -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); diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx index 1d3e608..855a243 100644 --- a/Source/cmNinjaTargetGenerator.cxx +++ b/Source/cmNinjaTargetGenerator.cxx @@ -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)); } diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx index 4b40c08..b821fda 100644 --- a/Source/cmQtAutoGenerators.cxx +++ b/Source/cmQtAutoGenerators.cxx @@ -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) diff --git a/Source/cmSetCommand.cxx b/Source/cmSetCommand.cxx index 1484368..8fb6aa0 100644 --- a/Source/cmSetCommand.cxx +++ b/Source/cmSetCommand.cxx @@ -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; diff --git a/Source/cmState.cxx b/Source/cmState.cxx index f2fe134..0470508 100644 --- a/Source/cmState.cxx +++ b/Source/cmState.cxx @@ -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"); } diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx index 2d463f3..9740ef7 100644 --- a/Source/cmSystemTools.cxx +++ b/Source/cmSystemTools.cxx @@ -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; } diff --git a/Source/cmTimestamp.cxx b/Source/cmTimestamp.cxx index c3c1d17..61b74db 100644 --- a/Source/cmTimestamp.cxx +++ b/Source/cmTimestamp.cxx @@ -93,10 +93,9 @@ time_t cmTimestamp::CreateUtcTimeTFromTm(struct tm& tm) const #else // From Linux timegm() manpage. - std::string tz_old = "TZ="; - if (const char* tz = cmSystemTools::GetEnv("TZ")) { - tz_old += tz; - } + std::string tz_old = ""; + cmSystemTools::GetEnv("TZ", tz_old); + tz_old = "TZ=" + tz_old; // The standard says that "TZ=" or "TZ=[UNRECOGNIZED_TZ]" means UTC. // It seems that "TZ=" does NOT work, at least under Windows diff --git a/Source/cmUtils.hxx b/Source/cmUtils.hxx new file mode 100644 index 0000000..fd1031e --- /dev/null +++ b/Source/cmUtils.hxx @@ -0,0 +1,26 @@ +/*============================================================================ + CMake - Cross Platform Makefile Generator + Copyright 2000-2016 Kitware, Inc., Insight Software Consortium + + Distributed under the OSI-approved BSD License (the "License"); + see accompanying file Copyright.txt for details. + + This software is distributed WITHOUT ANY WARRANTY; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the License for more information. +============================================================================*/ +#ifndef cmUtils_hxx +#define cmUtils_hxx + +#include <cmsys/SystemTools.hxx> + +// Use the make system's VERBOSE environment variable to enable +// verbose output. This can be skipped by also setting CMAKE_NO_VERBOSE +// (which is set by the Eclipse and KDevelop generators). +inline bool isCMakeVerbose() { + return (cmSystemTools::HasEnv("VERBOSE") && + !cmSystemTools::HasEnv("CMAKE_NO_VERBOSE")); +} + +#endif + diff --git a/Source/cmake.cxx b/Source/cmake.cxx index c597605..e4a9954 100644 --- a/Source/cmake.cxx +++ b/Source/cmake.cxx @@ -22,6 +22,7 @@ #include "cmSourceFile.h" #include "cmState.h" #include "cmTest.h" +#include "cmUtils.hxx" #if defined(CMAKE_BUILD_WITH_CMAKE) #include "cmGraphVizWriter.h" @@ -955,16 +956,10 @@ void cmake::SetGlobalGenerator(cmGlobalGenerator* gg) cmSystemTools::SetForceUnixPaths(this->GlobalGenerator->GetForceUnixPaths()); // Save the environment variables CXX and CC - const char* cxx = getenv("CXX"); - const char* cc = getenv("CC"); - if (cxx) { - this->CXXEnvironment = cxx; - } else { + if (!cmSystemTools::GetEnv("CXX", this->CXXEnvironment)) { this->CXXEnvironment = ""; } - if (cc) { - this->CCEnvironment = cc; - } else { + if (!cmSystemTools::GetEnv("CC", this->CCEnvironment)) { this->CCEnvironment = ""; } } @@ -1429,7 +1424,7 @@ int cmake::Run(const std::vector<std::string>& args, bool noconfigure) // should fail (if "-i" is an option). We cannot simply test // whether "-i" is given and remove it because some make programs // encode the MAKEFLAGS variable in a strange way. - if (getenv("MAKEFLAGS")) { + if (cmSystemTools::HasEnv("MAKEFLAGS")) { cmSystemTools::PutEnv("MAKEFLAGS="); } @@ -1704,12 +1699,8 @@ void cmake::UpdateConversionPathTable() int cmake::CheckBuildSystem() { - // We do not need to rerun CMake. Check dependency integrity. Use - // the make system's VERBOSE environment variable to enable verbose - // output. This can be skipped by setting CMAKE_NO_VERBOSE (which is set - // by the Eclipse and KDevelop generators). - bool verbose = ((cmSystemTools::GetEnv("VERBOSE") != CM_NULLPTR) && - (cmSystemTools::GetEnv("CMAKE_NO_VERBOSE") == CM_NULLPTR)); + // We do not need to rerun CMake. Check dependency integrity. + const bool verbose = isCMakeVerbose(); // This method will check the integrity of the build system if the // option was given on the command line. It reads the given file to diff --git a/Source/cmcmd.cxx b/Source/cmcmd.cxx index 010a3b2..8025d9b 100644 --- a/Source/cmcmd.cxx +++ b/Source/cmcmd.cxx @@ -17,6 +17,7 @@ #include "cmMakefile.h" #include "cmQtAutoGenerators.h" #include "cmVersion.h" +#include "cmUtils.hxx" #if defined(CMAKE_BUILD_WITH_CMAKE) #include "cmDependsFortran.h" // For -E cmake_copy_f90_mod callback. @@ -697,12 +698,7 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) // Internal CMake dependency scanning support. else if (args[1] == "cmake_depends" && args.size() >= 6) { - // Use the make system's VERBOSE environment variable to enable - // verbose output. This can be skipped by also setting CMAKE_NO_VERBOSE - // (which is set by the Eclipse and KDevelop generators). - bool verbose = - ((cmSystemTools::GetEnv("VERBOSE") != CM_NULLPTR) && - (cmSystemTools::GetEnv("CMAKE_NO_VERBOSE") == CM_NULLPTR)); + const bool verbose = isCMakeVerbose(); // Create a cmake object instance to process dependencies. cmake cm; @@ -900,9 +896,9 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) // 1/10th of a second after the untar. If CMAKE_UNTAR_DELAY // is set in the env, its value will be used instead of 100. int delay = 100; - const char* delayVar = cmSystemTools::GetEnv("CMAKE_UNTAR_DELAY"); - if (delayVar) { - delay = atoi(delayVar); + std::string delayVar; + if (cmSystemTools::GetEnv("CMAKE_UNTAR_DELAY", delayVar)) { + delay = atoi(delayVar.c_str()); } if (delay) { cmSystemTools::Delay(delay); @@ -1254,7 +1250,7 @@ int cmcmd::VisualStudioLink(std::vector<std::string>& args, int type) if (args.size() < 2) { return -1; } - bool verbose = cmSystemTools::GetEnv("VERBOSE") != CM_NULLPTR; + const bool verbose = cmSystemTools::HasEnv("VERBOSE"); std::vector<std::string> expandedArgs; for (std::vector<std::string>::iterator i = args.begin(); i != args.end(); ++i) { diff --git a/Source/kwsys/SystemInformation.cxx b/Source/kwsys/SystemInformation.cxx index 81fb2f9..1af7bdb 100644 --- a/Source/kwsys/SystemInformation.cxx +++ b/Source/kwsys/SystemInformation.cxx @@ -219,6 +219,8 @@ typedef struct rlimit ResourceLimitType; # define USE_CPUID 0 #endif +#include <cmsys/SystemTools.hxx> + #if USE_CPUID #define CPUID_AWARE_COMPILER @@ -3476,10 +3478,10 @@ SystemInformationImplementation::GetHostMemoryAvailable(const char *hostLimitEnv // apply a limit across a set of processes. Units are in KiB. if (hostLimitEnvVarName) { - const char *hostLimitEnvVarValue=getenv(hostLimitEnvVarName); - if (hostLimitEnvVarValue) + std::string hostLimitEnvVarValue; + if (SystemTools::GetEnv(hostLimitEnvVarName, hostLimitEnvVarValue)) { - SystemInformation::LongLong hostLimit=atoLongLong(hostLimitEnvVarValue); + SystemInformation::LongLong hostLimit=atoLongLong(hostLimitEnvVarValue.c_str()); if (hostLimit>0) { memTotal=min(hostLimit,memTotal); @@ -3506,10 +3508,10 @@ SystemInformationImplementation::GetProcMemoryAvailable( // are not employed. Units are in KiB. if (procLimitEnvVarName) { - const char *procLimitEnvVarValue=getenv(procLimitEnvVarName); - if (procLimitEnvVarValue) + std::string procLimitEnvVarValue; + if (SystemTools::GetEnv(procLimitEnvVarName, procLimitEnvVarValue)) { - SystemInformation::LongLong procLimit=atoLongLong(procLimitEnvVarValue); + SystemInformation::LongLong procLimit=atoLongLong(procLimitEnvVarValue.c_str()); if (procLimit>0) { memAvail=min(procLimit,memAvail); @@ -5408,11 +5410,7 @@ bool SystemInformationImplementation::QueryOSInformation() } this->Hostname = name; - const char* arch = getenv("PROCESSOR_ARCHITECTURE"); - if(arch) - { - this->OSPlatform = arch; - } + SystemTools::GetEnv("PROCESSOR_ARCHITECTURE", this->OSPlatform); #else diff --git a/Source/kwsys/SystemTools.cxx b/Source/kwsys/SystemTools.cxx index 2b1db4d..ace5126 100644 --- a/Source/kwsys/SystemTools.cxx +++ b/Source/kwsys/SystemTools.cxx @@ -421,14 +421,12 @@ void SystemTools::GetPath(std::vector<std::string>& path, const char* env) { env = "PATH"; } - const char* cpathEnv = SystemTools::GetEnv(env); - if ( !cpathEnv ) + std::string pathEnv; + if ( !SystemTools::GetEnv(env, pathEnv) ) { return; } - std::string pathEnv = cpathEnv; - // A hack to make the below algorithm work. if(!pathEnv.empty() && *pathEnv.rbegin() != pathSep) { @@ -2082,8 +2080,8 @@ void SystemTools::ConvertToUnixSlashes(std::string& path) pathCString = path.c_str(); if(pathCString[0] == '~' && (pathCString[1] == '/' || pathCString[1] == '\0')) { - const char* homeEnv = SystemTools::GetEnv("HOME"); - if (homeEnv) + std::string homeEnv; + if (SystemTools::GetEnv("HOME", homeEnv)) { path.replace(0,1,homeEnv); } @@ -4099,16 +4097,9 @@ void SystemTools::SplitPath(const std::string& p, if(root.size() == 1) { #if defined(_WIN32) && !defined(__CYGWIN__) - if(const char* userp = getenv("USERPROFILE")) - { - homedir = userp; - } - else + if (!SystemTools::GetEnv("USERPROFILE", homedir)) #endif - if(const char* h = getenv("HOME")) - { - homedir = h; - } + SystemTools::GetEnv("HOME", homedir); } #ifdef HAVE_GETPWNAM else if(passwd* pw = getpwnam(root.c_str()+1)) @@ -4849,7 +4840,7 @@ int SystemTools::GetTerminalWidth() int width = -1; #ifdef HAVE_TTY_INFO struct winsize ws; - char *columns; /* Unix98 environment variable */ + std::string columns; /* Unix98 environment variable */ if(ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col>0 && ws.ws_row>0) { width = ws.ws_col; @@ -4858,12 +4849,11 @@ int SystemTools::GetTerminalWidth() { width = -1; } - columns = getenv("COLUMNS"); - if(columns && *columns) + if(SystemTools::GetEnv("COLUMNS", columns) && !columns.empty()) { long t; char *endptr; - t = strtol(columns, &endptr, 0); + t = strtol(columns.c_str(), &endptr, 0); if(endptr && !*endptr && (t>0) && (t<1000)) { width = static_cast<int>(t); @@ -5473,7 +5463,8 @@ void SystemTools::ClassInitialize() // If the current working directory is a logical path then keep the // logical name. - if(const char* pwd = getenv("PWD")) + std::string pwd_str; + if(SystemTools::GetEnv("PWD", pwd_str)) { char buf[2048]; if(const char* cwd = Getcwd(buf, 2048)) @@ -5485,10 +5476,9 @@ void SystemTools::ClassInitialize() std::string pwd_changed; // Test progressively shorter logical-to-physical mappings. - std::string pwd_str = pwd; std::string cwd_str = cwd; std::string pwd_path; - Realpath(pwd, pwd_path); + Realpath(pwd_str.c_str(), pwd_path); while(cwd_str == pwd_path && cwd_str != pwd_str) { // The current pair of paths is a working logical mapping. @@ -5543,8 +5533,8 @@ static int SystemToolsDebugReport(int, char* message, int*) void SystemTools::EnableMSVCDebugHook() { - if (getenv("DART_TEST_FROM_DART") || - getenv("DASHBOARD_TEST_FROM_CTEST")) + if (SystemTools::HasEnv("DART_TEST_FROM_DART") || + SystemTools::HasEnv("DASHBOARD_TEST_FROM_CTEST")) { _CrtSetReportHook(SystemToolsDebugReport); } diff --git a/Source/kwsys/testSystemTools.cxx b/Source/kwsys/testSystemTools.cxx index 4d97688..4dab347 100644 --- a/Source/kwsys/testSystemTools.cxx +++ b/Source/kwsys/testSystemTools.cxx @@ -848,9 +848,9 @@ static bool CheckPutEnv(const std::string& env, const char* name, const char* va << "\") failed!" << std::endl; return false; } - const char* v = kwsys::SystemTools::GetEnv(name); - v = v? v : "(null)"; - if(strcmp(v, value) != 0) + std::string v = "(null)"; + kwsys::SystemTools::GetEnv(name, v); + if(v != value) { std::cerr << "GetEnv(\"" << name << "\") returned \"" << v << "\", not \"" << value << "\"!" << std::endl; @@ -867,7 +867,8 @@ static bool CheckUnPutEnv(const char* env, const char* name) << std::endl; return false; } - if(const char* v = kwsys::SystemTools::GetEnv(name)) + std::string v; + if(kwsys::SystemTools::GetEnv(name, v)) { std::cerr << "GetEnv(\"" << name << "\") returned \"" << v << "\", not (null)!" << std::endl; -- 2.9.0 -- Powered by www.kitware.com Please keep messages on-topic and check the CMake FAQ at: http://www.cmake.org/Wiki/CMake_FAQ Kitware offers various services to support the CMake community. For more information on each offering, please visit: CMake Support: http://cmake.org/cmake/help/support.html CMake Consulting: http://cmake.org/cmake/help/consulting.html CMake Training Courses: http://cmake.org/cmake/help/training.html Visit other Kitware open-source projects at http://www.kitware.com/opensource/opensource.html Follow this link to subscribe/unsubscribe: http://public.kitware.com/mailman/listinfo/cmake-developers