reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-11-24 20:19:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

cmMakefile: Let AddDefinition accept a value as cm::string_view

Browse Source 
This changes `cmMakefile::AddDefinition` to take a `cm::string_view` as value
argument instead of a `const char *`.

Benefits are:
- `std::string` can be passed to `cmMakefile::AddDefinition` directly without
  the `c_str()` plus string length recomputation fallback.
- Lengths of literals passed to `cmMakefile::AddDefinition` can be computed at
  compile time.

In various sources uses of `cmMakefile::AddDefinition` are adapted to avoid
`std::string::c_str` calls and the `std::string` is passed directly.
Uses of `cmMakefile::AddDefinition`, where a `nullptr` `const char*` might
be passed to `cmMakefile::AddDefinition` are extended with `nullptr` checks.
This commit is contained in:
Sebastian Holtermann 2019-07-17 16:20:58 +02:00
parent f2ba968ef2
commit e91bfe440c
56 changed files with 226 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
Source/CPack/cmCPackGenerator.cxx
View File

@ -759,7 +759,7 @@ int cmCPackGenerator::InstallCMakeProject(
if (this->GetOption("CPACK_INSTALL_PREFIX")) { if (this->GetOption("CPACK_INSTALL_PREFIX")) {
dir += this->GetOption("CPACK_INSTALL_PREFIX"); dir += this->GetOption("CPACK_INSTALL_PREFIX");
} }
mf.AddDefinition("CMAKE_INSTALL_PREFIX", dir.c_str()); mf.AddDefinition("CMAKE_INSTALL_PREFIX", dir);
cmCPackLogger( cmCPackLogger(
cmCPackLog::LOG_DEBUG, cmCPackLog::LOG_DEBUG,
@ -799,7 +799,7 @@ int cmCPackGenerator::InstallCMakeProject(
return 0; return 0;
} }
} else { } else {
mf.AddDefinition("CMAKE_INSTALL_PREFIX", tempInstallDirectory.c_str()); mf.AddDefinition("CMAKE_INSTALL_PREFIX", tempInstallDirectory);
if (!cmsys::SystemTools::MakeDirectory(tempInstallDirectory, if (!cmsys::SystemTools::MakeDirectory(tempInstallDirectory,
default_dir_mode)) { default_dir_mode)) {
@ -818,11 +818,11 @@ int cmCPackGenerator::InstallCMakeProject(
} }
if (!buildConfig.empty()) { if (!buildConfig.empty()) {
mf.AddDefinition("BUILD_TYPE", buildConfig.c_str()); mf.AddDefinition("BUILD_TYPE", buildConfig);
} }
std::string installComponentLowerCase = cmSystemTools::LowerCase(component); std::string installComponentLowerCase = cmSystemTools::LowerCase(component);
if (installComponentLowerCase != "all") { if (installComponentLowerCase != "all") {
mf.AddDefinition("CMAKE_INSTALL_COMPONENT", component.c_str()); mf.AddDefinition("CMAKE_INSTALL_COMPONENT", component);
} }
// strip on TRUE, ON, 1, one or several file names, but not on // strip on TRUE, ON, 1, one or several file names, but not on
@ -863,9 +863,8 @@ int cmCPackGenerator::InstallCMakeProject(
// forward definition of CMAKE_ABSOLUTE_DESTINATION_FILES // forward definition of CMAKE_ABSOLUTE_DESTINATION_FILES
// to CPack (may be used by generators like CPack RPM or DEB) // to CPack (may be used by generators like CPack RPM or DEB)
// in order to transparently handle ABSOLUTE PATH // in order to transparently handle ABSOLUTE PATH
if (mf.GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES")) { if (const char* def = mf.GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES")) {
mf.AddDefinition("CPACK_ABSOLUTE_DESTINATION_FILES", mf.AddDefinition("CPACK_ABSOLUTE_DESTINATION_FILES", def);
mf.GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES"));
} }
// Now rebuild the list of files after installation // Now rebuild the list of files after installation

21
Source/CPack/cpack.cxx
View File

@ -270,7 +270,7 @@ int main(int argc, char const* const* argv)
} }
if (!cpackBuildConfig.empty()) { if (!cpackBuildConfig.empty()) {
globalMF.AddDefinition("CPACK_BUILD_CONFIG", cpackBuildConfig.c_str()); globalMF.AddDefinition("CPACK_BUILD_CONFIG", cpackBuildConfig);
} }
if (cmSystemTools::FileExists(cpackConfigFile)) { if (cmSystemTools::FileExists(cpackConfigFile)) {
@ -292,24 +292,21 @@ int main(int argc, char const* const* argv)
} }
if (!generator.empty()) { if (!generator.empty()) {
globalMF.AddDefinition("CPACK_GENERATOR", generator.c_str()); globalMF.AddDefinition("CPACK_GENERATOR", generator);
} }
if (!cpackProjectName.empty()) { if (!cpackProjectName.empty()) {
globalMF.AddDefinition("CPACK_PACKAGE_NAME", cpackProjectName.c_str()); globalMF.AddDefinition("CPACK_PACKAGE_NAME", cpackProjectName);
} }
if (!cpackProjectVersion.empty()) { if (!cpackProjectVersion.empty()) {
globalMF.AddDefinition("CPACK_PACKAGE_VERSION", globalMF.AddDefinition("CPACK_PACKAGE_VERSION", cpackProjectVersion);
cpackProjectVersion.c_str());
} }
if (!cpackProjectVendor.empty()) { if (!cpackProjectVendor.empty()) {
globalMF.AddDefinition("CPACK_PACKAGE_VENDOR", globalMF.AddDefinition("CPACK_PACKAGE_VENDOR", cpackProjectVendor);
cpackProjectVendor.c_str());
} }
// if this is not empty it has been set on the command line // if this is not empty it has been set on the command line
// go for it. Command line override values set in config file. // go for it. Command line override values set in config file.
if (!cpackProjectDirectory.empty()) { if (!cpackProjectDirectory.empty()) {
globalMF.AddDefinition("CPACK_PACKAGE_DIRECTORY", globalMF.AddDefinition("CPACK_PACKAGE_DIRECTORY", cpackProjectDirectory);
cpackProjectDirectory.c_str());
} }
// The value has not been set on the command line // The value has not been set on the command line
else { else {
@ -318,11 +315,11 @@ int main(int argc, char const* const* argv)
// use default value iff no value has been provided by the config file // use default value iff no value has been provided by the config file
if (!globalMF.IsSet("CPACK_PACKAGE_DIRECTORY")) { if (!globalMF.IsSet("CPACK_PACKAGE_DIRECTORY")) {
globalMF.AddDefinition("CPACK_PACKAGE_DIRECTORY", globalMF.AddDefinition("CPACK_PACKAGE_DIRECTORY",
cpackProjectDirectory.c_str()); cpackProjectDirectory);
} }
} }
for (auto const& cd : definitions.Map) { for (auto const& cd : definitions.Map) {
globalMF.AddDefinition(cd.first, cd.second.c_str()); globalMF.AddDefinition(cd.first, cd.second);
} }
const char* cpackModulesPath = globalMF.GetDefinition("CPACK_MODULE_PATH"); const char* cpackModulesPath = globalMF.GetDefinition("CPACK_MODULE_PATH");
@ -426,7 +423,7 @@ int main(int argc, char const* const* argv)
std::ostringstream ostr; std::ostringstream ostr;
ostr << projVersionMajor << "." << projVersionMinor << "." ostr << projVersionMajor << "." << projVersionMinor << "."
<< projVersionPatch; << projVersionPatch;
mf->AddDefinition("CPACK_PACKAGE_VERSION", ostr.str().c_str()); mf->AddDefinition("CPACK_PACKAGE_VERSION", ostr.str());
} }
int res = cpackGenerator->DoPackage(); int res = cpackGenerator->DoPackage();

5
Source/CTest/cmCTestBuildCommand.cxx
View File

@ -156,15 +156,14 @@ bool cmCTestBuildCommand::InitialPass(std::vector<std::string> const& args,
if (this->Values[ctb_NUMBER_ERRORS] && *this->Values[ctb_NUMBER_ERRORS]) { if (this->Values[ctb_NUMBER_ERRORS] && *this->Values[ctb_NUMBER_ERRORS]) {
std::ostringstream str; std::ostringstream str;
str << this->Handler->GetTotalErrors(); str << this->Handler->GetTotalErrors();
this->Makefile->AddDefinition(this->Values[ctb_NUMBER_ERRORS], this->Makefile->AddDefinition(this->Values[ctb_NUMBER_ERRORS], str.str());
str.str().c_str());
} }
if (this->Values[ctb_NUMBER_WARNINGS] && if (this->Values[ctb_NUMBER_WARNINGS] &&
*this->Values[ctb_NUMBER_WARNINGS]) { *this->Values[ctb_NUMBER_WARNINGS]) {
std::ostringstream str; std::ostringstream str;
str << this->Handler->GetTotalWarnings(); str << this->Handler->GetTotalWarnings();
this->Makefile->AddDefinition(this->Values[ctb_NUMBER_WARNINGS], this->Makefile->AddDefinition(this->Values[ctb_NUMBER_WARNINGS],
str.str().c_str()); str.str());
} }
return ret; return ret;
} }

3
Source/CTest/cmCTestHandlerCommand.cxx
View File

@ -230,8 +230,7 @@ bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args,
if (this->Values[ct_RETURN_VALUE] && *this->Values[ct_RETURN_VALUE]) { if (this->Values[ct_RETURN_VALUE] && *this->Values[ct_RETURN_VALUE]) {
std::ostringstream str; std::ostringstream str;
str << res; str << res;
this->Makefile->AddDefinition(this->Values[ct_RETURN_VALUE], this->Makefile->AddDefinition(this->Values[ct_RETURN_VALUE], str.str());
str.str().c_str());
} }
this->ProcessAdditionalValues(handler); this->ProcessAdditionalValues(handler);
// log the error message if there was an error // log the error message if there was an error

4
Source/CTest/cmCTestMemCheckCommand.cxx
View File

@ -3,7 +3,6 @@
#include "cmCTestMemCheckCommand.h" #include "cmCTestMemCheckCommand.h"
#include <sstream> #include <sstream>
#include <string>
#include <vector> #include <vector>
#include "cmCTest.h" #include "cmCTest.h"
@ -47,7 +46,6 @@ void cmCTestMemCheckCommand::ProcessAdditionalValues(
if (this->Values[ctm_DEFECT_COUNT] && *this->Values[ctm_DEFECT_COUNT]) { if (this->Values[ctm_DEFECT_COUNT] && *this->Values[ctm_DEFECT_COUNT]) {
std::ostringstream str; std::ostringstream str;
str << static_cast<cmCTestMemCheckHandler*>(handler)->GetDefectCount(); str << static_cast<cmCTestMemCheckHandler*>(handler)->GetDefectCount();
this->Makefile->AddDefinition(this->Values[ctm_DEFECT_COUNT], this->Makefile->AddDefinition(this->Values[ctm_DEFECT_COUNT], str.str());
str.str().c_str());
} }
} }

2
Source/CTest/cmCTestRunScriptCommand.cxx
View File

@ -43,7 +43,7 @@ bool cmCTestRunScriptCommand::InitialPass(std::vector<std::string> const& args,
args[i].c_str(), !np, &ret); args[i].c_str(), !np, &ret);
std::ostringstream str; std::ostringstream str;
str << ret; str << ret;
this->Makefile->AddDefinition(returnVariable, str.str().c_str()); this->Makefile->AddDefinition(returnVariable, str.str());
} }
} }
return true; return true;

18
Source/CTest/cmCTestScriptHandler.cxx
View File

@ -168,7 +168,7 @@ void cmCTestScriptHandler::UpdateElapsedTime()
auto itime = cmDurationTo<unsigned int>(std::chrono::steady_clock::now() - auto itime = cmDurationTo<unsigned int>(std::chrono::steady_clock::now() -
this->ScriptStartTime); this->ScriptStartTime);
auto timeString = std::to_string(itime); auto timeString = std::to_string(itime);
this->Makefile->AddDefinition("CTEST_ELAPSED_TIME", timeString.c_str()); this->Makefile->AddDefinition("CTEST_ELAPSED_TIME", timeString);
} }
} }
@ -352,21 +352,21 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg)
this->CreateCMake(); this->CreateCMake();
// set a variable with the path to the current script // set a variable with the path to the current script
this->Makefile->AddDefinition( this->Makefile->AddDefinition("CTEST_SCRIPT_DIRECTORY",
"CTEST_SCRIPT_DIRECTORY", cmSystemTools::GetFilenamePath(script).c_str()); cmSystemTools::GetFilenamePath(script));
this->Makefile->AddDefinition( this->Makefile->AddDefinition("CTEST_SCRIPT_NAME",
"CTEST_SCRIPT_NAME", cmSystemTools::GetFilenameName(script).c_str()); cmSystemTools::GetFilenameName(script));
this->Makefile->AddDefinition("CTEST_EXECUTABLE_NAME", this->Makefile->AddDefinition("CTEST_EXECUTABLE_NAME",
cmSystemTools::GetCTestCommand().c_str()); cmSystemTools::GetCTestCommand());
this->Makefile->AddDefinition("CMAKE_EXECUTABLE_NAME", this->Makefile->AddDefinition("CMAKE_EXECUTABLE_NAME",
cmSystemTools::GetCMakeCommand().c_str()); cmSystemTools::GetCMakeCommand());
this->Makefile->AddDefinitionBool("CTEST_RUN_CURRENT_SCRIPT", true); this->Makefile->AddDefinitionBool("CTEST_RUN_CURRENT_SCRIPT", true);
this->SetRunCurrentScript(true); this->SetRunCurrentScript(true);
this->UpdateElapsedTime(); this->UpdateElapsedTime();
// add the script arg if defined // add the script arg if defined
if (!script_arg.empty()) { if (!script_arg.empty()) {
this->Makefile->AddDefinition("CTEST_SCRIPT_ARG", script_arg.c_str()); this->Makefile->AddDefinition("CTEST_SCRIPT_ARG", script_arg);
} }
#if defined(__CYGWIN__) #if defined(__CYGWIN__)
@ -398,7 +398,7 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg)
const std::map<std::string, std::string>& defs = const std::map<std::string, std::string>& defs =
this->CTest->GetDefinitions(); this->CTest->GetDefinitions();
for (auto const& d : defs) { for (auto const& d : defs) {
this->Makefile->AddDefinition(d.first, d.second.c_str()); this->Makefile->AddDefinition(d.first, d.second);
} }
// finally read in the script // finally read in the script

2
Source/CTest/cmCTestSubmitCommand.cxx
View File

@ -143,7 +143,7 @@ bool cmCTestSubmitCommand::InitialPass(std::vector<std::string> const& args,
if (this->Values[cts_BUILD_ID] && *this->Values[cts_BUILD_ID]) { if (this->Values[cts_BUILD_ID] && *this->Values[cts_BUILD_ID]) {
this->Makefile->AddDefinition(this->Values[cts_BUILD_ID], this->Makefile->AddDefinition(this->Values[cts_BUILD_ID],
this->CTest->GetBuildID().c_str()); this->CTest->GetBuildID());
} }
return ret; return ret;

3
Source/CTest/cmCTestTestHandler.cxx
View File

@ -1714,8 +1714,7 @@ void cmCTestTestHandler::GetListOfTests()
cm.GetCurrentSnapshot().SetDefaultDefinitions(); cm.GetCurrentSnapshot().SetDefaultDefinitions();
cmGlobalGenerator gg(&cm); cmGlobalGenerator gg(&cm);
cmMakefile mf(&gg, cm.GetCurrentSnapshot()); cmMakefile mf(&gg, cm.GetCurrentSnapshot());
mf.AddDefinition("CTEST_CONFIGURATION_TYPE", mf.AddDefinition("CTEST_CONFIGURATION_TYPE", this->CTest->GetConfigType());
this->CTest->GetConfigType().c_str());
// Add handler for ADD_TEST // Add handler for ADD_TEST
auto newCom1 = cm::make_unique<cmCTestAddTestCommand>(); auto newCom1 = cm::make_unique<cmCTestAddTestCommand>();

2
Source/cmAuxSourceDirectoryCommand.cxx
View File

@ -74,6 +74,6 @@ bool cmAuxSourceDirectoryCommand::InitialPass(
sourceListValue += ";"; sourceListValue += ";";
} }
sourceListValue += cmJoin(files, ";"); sourceListValue += cmJoin(files, ";");
this->Makefile->AddDefinition(args[1], sourceListValue.c_str()); this->Makefile->AddDefinition(args[1], sourceListValue);
return true; return true;
} }

2
Source/cmBuildCommand.cxx
View File

@ -92,7 +92,7 @@ bool cmBuildCommand::MainSignature(std::vector<std::string> const& args)
this->Makefile->GetGlobalGenerator()->GenerateCMakeBuildCommand( this->Makefile->GetGlobalGenerator()->GenerateCMakeBuildCommand(
target, configuration, "", this->Makefile->IgnoreErrorsCMP0061()); target, configuration, "", this->Makefile->IgnoreErrorsCMP0061());
this->Makefile->AddDefinition(variable, makecommand.c_str()); this->Makefile->AddDefinition(variable, makecommand);
return true; return true;
} }

2
Source/cmCMakeHostSystemInformationCommand.cxx
View File

@ -55,7 +55,7 @@ bool cmCMakeHostSystemInformationCommand::InitialPass(
result_list += value; result_list += value;
} }
this->Makefile->AddDefinition(variable, result_list.c_str()); this->Makefile->AddDefinition(variable, result_list);
return true; return true;
} }

3
Source/cmCMakeMinimumRequired.cxx
View File

@ -61,8 +61,7 @@ bool cmCMakeMinimumRequired::InitialPass(std::vector<std::string> const& args,
} }
// Save the required version string. // Save the required version string.
this->Makefile->AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION", this->Makefile->AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION", version_min);
version_min.c_str());
// Get the current version number. // Get the current version number.
unsigned int current_major = cmVersion::GetMajorVersion(); unsigned int current_major = cmVersion::GetMajorVersion();

3
Source/cmCMakePolicyCommand.cxx
View File

@ -209,8 +209,7 @@ bool cmCMakePolicyCommand::HandleGetWarningMode(
} }
// Lookup the policy warning. // Lookup the policy warning.
this->Makefile->AddDefinition(var, this->Makefile->AddDefinition(var, cmPolicies::GetPolicyWarning(pid));
cmPolicies::GetPolicyWarning(pid).c_str());
return true; return true;
} }

6
Source/cmCPluginAPI.cxx
View File

@ -65,8 +65,10 @@ unsigned int CCONV cmGetMinorVersion(void*)
void CCONV cmAddDefinition(void* arg, const char* name, const char* value) void CCONV cmAddDefinition(void* arg, const char* name, const char* value)
{ {
cmMakefile* mf = static_cast<cmMakefile*>(arg); if (value) {
mf->AddDefinition(name, value); cmMakefile* mf = static_cast<cmMakefile*>(arg);
mf->AddDefinition(name, value);
}
} }
/* Add a definition to this makefile and the global cmake cache. */ /* Add a definition to this makefile and the global cmake cache. */

5
Source/cmCoreTryCompile.cxx
View File

@ -932,7 +932,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
cmStateEnums::INTERNAL); cmStateEnums::INTERNAL);
if (!outputVariable.empty()) { if (!outputVariable.empty()) {
this->Makefile->AddDefinition(outputVariable, output.c_str()); this->Makefile->AddDefinition(outputVariable, output);
} }
if (this->SrcFileSignature) { if (this->SrcFileSignature) {
@ -961,8 +961,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
} }
if (!copyFileError.empty()) { if (!copyFileError.empty()) {
this->Makefile->AddDefinition(copyFileError, this->Makefile->AddDefinition(copyFileError, copyFileErrorMessage);
copyFileErrorMessage.c_str());
} }
} }
return res; return res;

11
Source/cmCreateTestSourceList.cxx
View File

@ -125,16 +125,15 @@ bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& args,
} }
if (!extraInclude.empty()) { if (!extraInclude.empty()) {
this->Makefile->AddDefinition("CMAKE_TESTDRIVER_EXTRA_INCLUDES", this->Makefile->AddDefinition("CMAKE_TESTDRIVER_EXTRA_INCLUDES",
extraInclude.c_str()); extraInclude);
} }
if (!function.empty()) { if (!function.empty()) {
this->Makefile->AddDefinition("CMAKE_TESTDRIVER_ARGVC_FUNCTION", this->Makefile->AddDefinition("CMAKE_TESTDRIVER_ARGVC_FUNCTION", function);
function.c_str());
} }
this->Makefile->AddDefinition("CMAKE_FORWARD_DECLARE_TESTS", this->Makefile->AddDefinition("CMAKE_FORWARD_DECLARE_TESTS",
forwardDeclareCode.c_str()); forwardDeclareCode);
this->Makefile->AddDefinition("CMAKE_FUNCTION_TABLE_ENTIRES", this->Makefile->AddDefinition("CMAKE_FUNCTION_TABLE_ENTIRES",
functionMapCode.c_str()); functionMapCode);
bool res = true; bool res = true;
if (!this->Makefile->ConfigureFile(configFile, driver, false, true, false)) { if (!this->Makefile->ConfigureFile(configFile, driver, false, true, false)) {
res = false; res = false;
@ -154,6 +153,6 @@ bool cmCreateTestSourceList::InitialPass(std::vector<std::string> const& args,
sourceListValue += *i; sourceListValue += *i;
} }
this->Makefile->AddDefinition(sourceList, sourceListValue.c_str()); this->Makefile->AddDefinition(sourceList, sourceListValue);
return res; return res;
} }

2
Source/cmExecProgramCommand.cxx
View File

@ -103,7 +103,7 @@ bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& args,
} }
std::string coutput = std::string(output, first, last - first + 1); std::string coutput = std::string(output, first, last - first + 1);
this->Makefile->AddDefinition(output_variable, coutput.c_str()); this->Makefile->AddDefinition(output_variable, coutput);
} }
if (!return_variable.empty()) { if (!return_variable.empty()) {

2
Source/cmExecuteProcessCommand.cxx
View File

@ -332,7 +332,7 @@ bool cmExecuteProcessCommand::InitialPass(std::vector<std::string> const& args,
} }
} }
this->Makefile->AddDefinition(arguments.ResultsVariable, this->Makefile->AddDefinition(arguments.ResultsVariable,
cmJoin(res, ";").c_str()); cmJoin(res, ";"));
} break; } break;
case cmsysProcess_State_Exception: case cmsysProcess_State_Exception:
this->Makefile->AddDefinition(arguments.ResultsVariable, this->Makefile->AddDefinition(arguments.ResultsVariable,

3
Source/cmFLTKWrapUICommand.cxx
View File

@ -117,8 +117,9 @@ bool cmFLTKWrapUICommand::InitialPass(std::vector<std::string> const& args,
} }
sourceListValue += generatedSourcesClasses[classNum]->GetFullPath(); sourceListValue += generatedSourcesClasses[classNum]->GetFullPath();
} }
std::string const varName = target + "_FLTK_UI_SRCS"; std::string const varName = target + "_FLTK_UI_SRCS";
this->Makefile->AddDefinition(varName, sourceListValue.c_str()); this->Makefile->AddDefinition(varName, sourceListValue);
this->Makefile->AddFinalAction( this->Makefile->AddFinalAction(
[target](cmMakefile& makefile) { FinalAction(makefile, target); }); [target](cmMakefile& makefile) { FinalAction(makefile, target); });

55
Source/cmFileCommand.cxx
View File

@ -365,7 +365,7 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
} }
} }
} }
this->Makefile->AddDefinition(variable, output.c_str()); this->Makefile->AddDefinition(variable, output);
return true; return true;
} }
@ -383,7 +383,7 @@ bool cmFileCommand::HandleHashCommand(std::vector<std::string> const& args)
if (hash) { if (hash) {
std::string out = hash->HashFile(args[1]); std::string out = hash->HashFile(args[1]);
if (!out.empty()) { if (!out.empty()) {
this->Makefile->AddDefinition(args[2], out.c_str()); this->Makefile->AddDefinition(args[2], out);
return true; return true;
} }
std::ostringstream e; std::ostringstream e;
@ -751,7 +751,7 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
} }
// Save the output in a makefile variable. // Save the output in a makefile variable.
this->Makefile->AddDefinition(outVar, output.c_str()); this->Makefile->AddDefinition(outVar, output);
return true; return true;
} }
@ -938,7 +938,7 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
std::sort(files.begin(), files.end()); std::sort(files.begin(), files.end());
files.erase(std::unique(files.begin(), files.end()), files.end()); files.erase(std::unique(files.begin(), files.end()), files.end());
this->Makefile->AddDefinition(variable, cmJoin(files, ";").c_str()); this->Makefile->AddDefinition(variable, cmJoin(files, ";"));
return true; return true;
} }
@ -1298,14 +1298,14 @@ bool cmFileCommand::HandleReadElfCommand(std::vector<std::string> const& args)
if (cmELF::StringEntry const* se_rpath = elf.GetRPath()) { if (cmELF::StringEntry const* se_rpath = elf.GetRPath()) {
std::string rpath(se_rpath->Value); std::string rpath(se_rpath->Value);
std::replace(rpath.begin(), rpath.end(), ':', ';'); std::replace(rpath.begin(), rpath.end(), ':', ';');
this->Makefile->AddDefinition(arguments.RPath, rpath.c_str()); this->Makefile->AddDefinition(arguments.RPath, rpath);
} }
} }
if (!arguments.RunPath.empty()) { if (!arguments.RunPath.empty()) {
if (cmELF::StringEntry const* se_runpath = elf.GetRunPath()) { if (cmELF::StringEntry const* se_runpath = elf.GetRunPath()) {
std::string runpath(se_runpath->Value); std::string runpath(se_runpath->Value);
std::replace(runpath.begin(), runpath.end(), ':', ';'); std::replace(runpath.begin(), runpath.end(), ':', ';');
this->Makefile->AddDefinition(arguments.RunPath, runpath.c_str()); this->Makefile->AddDefinition(arguments.RunPath, runpath);
} }
} }
@ -1316,7 +1316,7 @@ bool cmFileCommand::HandleReadElfCommand(std::vector<std::string> const& args)
this->SetError(error); this->SetError(error);
return false; return false;
} }
this->Makefile->AddDefinition(arguments.Error, error.c_str()); this->Makefile->AddDefinition(arguments.Error, error);
return true; return true;
#endif #endif
} }
@ -1354,7 +1354,7 @@ bool cmFileCommand::HandleRelativePathCommand(
} }
std::string res = cmSystemTools::RelativePath(directoryName, fileName); std::string res = cmSystemTools::RelativePath(directoryName, fileName);
this->Makefile->AddDefinition(outVar, res.c_str()); this->Makefile->AddDefinition(outVar, res);
return true; return true;
} }
@ -1460,7 +1460,7 @@ bool cmFileCommand::HandleCMakePathCommand(
std::string value = cmJoin( std::string value = cmJoin(
cmMakeRange(path).transform(nativePath ? ToNativePath : ToCMakePath), ";"); cmMakeRange(path).transform(nativePath ? ToNativePath : ToCMakePath), ";");
this->Makefile->AddDefinition(args[2], value.c_str()); this->Makefile->AddDefinition(args[2], value);
return true; return true;
} }
@ -1800,7 +1800,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
if (!statusVar.empty()) { if (!statusVar.empty()) {
std::ostringstream result; std::ostringstream result;
result << 0 << ";\"" << msg; result << 0 << ";\"" << msg;
this->Makefile->AddDefinition(statusVar, result.str().c_str()); this->Makefile->AddDefinition(statusVar, result.str());
} }
return true; return true;
} }
@ -1949,7 +1949,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
std::ostringstream result; std::ostringstream result;
result << static_cast<int>(res) << ";\"" << ::curl_easy_strerror(res) result << static_cast<int>(res) << ";\"" << ::curl_easy_strerror(res)
<< "\""; << "\"";
this->Makefile->AddDefinition(statusVar, result.str().c_str()); this->Makefile->AddDefinition(statusVar, result.str());
} }
::curl_global_cleanup(); ::curl_global_cleanup();
@ -1981,7 +1981,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
std::string status = "1;HASH mismatch: " std::string status = "1;HASH mismatch: "
"expected: " + "expected: " +
expectedHash + " actual: " + actualHash; expectedHash + " actual: " + actualHash;
this->Makefile->AddDefinition(statusVar, status.c_str()); this->Makefile->AddDefinition(statusVar, status);
} }
this->SetError(oss.str()); this->SetError(oss.str());
@ -2236,7 +2236,7 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
std::ostringstream result; std::ostringstream result;
result << static_cast<int>(res) << ";\"" << ::curl_easy_strerror(res) result << static_cast<int>(res) << ";\"" << ::curl_easy_strerror(res)
<< "\""; << "\"";
this->Makefile->AddDefinition(statusVar, result.str().c_str()); this->Makefile->AddDefinition(statusVar, result.str());
} }
::curl_global_cleanup(); ::curl_global_cleanup();
@ -2261,7 +2261,7 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
log += "\n"; log += "\n";
} }
this->Makefile->AddDefinition(logVar, log.c_str()); this->Makefile->AddDefinition(logVar, log);
} }
return true; return true;
@ -2479,7 +2479,7 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
} }
if (!resultVariable.empty()) { if (!resultVariable.empty()) {
this->Makefile->AddDefinition(resultVariable, result.c_str()); this->Makefile->AddDefinition(resultVariable, result);
} }
return true; return true;
@ -2528,7 +2528,7 @@ bool cmFileCommand::HandleTimestampCommand(
cmTimestamp timestamp; cmTimestamp timestamp;
std::string result = std::string result =
timestamp.FileModificationTime(filename.c_str(), formatString, utcFlag); timestamp.FileModificationTime(filename.c_str(), formatString, utcFlag);
this->Makefile->AddDefinition(outputVariable, result.c_str()); this->Makefile->AddDefinition(outputVariable, result);
return true; return true;
} }
@ -2556,8 +2556,7 @@ bool cmFileCommand::HandleSizeCommand(std::vector<std::string> const& args)
} }
this->Makefile->AddDefinition( this->Makefile->AddDefinition(
outputVariable, outputVariable, std::to_string(cmSystemTools::FileLength(filename)));
std::to_string(cmSystemTools::FileLength(filename)).c_str());
return true; return true;
} }
@ -2584,7 +2583,7 @@ bool cmFileCommand::HandleReadSymlinkCommand(
return false; return false;
} }
this->Makefile->AddDefinition(outputVariable, result.c_str()); this->Makefile->AddDefinition(outputVariable, result);
return true; return true;
} }
@ -2630,7 +2629,7 @@ bool cmFileCommand::HandleCreateLinkCommand(
if (fileName == newFileName) { if (fileName == newFileName) {
result = "CREATE_LINK cannot use same file and newfile"; result = "CREATE_LINK cannot use same file and newfile";
if (!arguments.Result.empty()) { if (!arguments.Result.empty()) {
this->Makefile->AddDefinition(arguments.Result, result.c_str()); this->Makefile->AddDefinition(arguments.Result, result);
return true; return true;
} }
this->SetError(result); this->SetError(result);
@ -2641,7 +2640,7 @@ bool cmFileCommand::HandleCreateLinkCommand(
if (!arguments.Symbolic && !cmSystemTools::FileExists(fileName)) { if (!arguments.Symbolic && !cmSystemTools::FileExists(fileName)) {
result = "Cannot hard link \'" + fileName + "\' as it does not exist."; result = "Cannot hard link \'" + fileName + "\' as it does not exist.";
if (!arguments.Result.empty()) { if (!arguments.Result.empty()) {
this->Makefile->AddDefinition(arguments.Result, result.c_str()); this->Makefile->AddDefinition(arguments.Result, result);
return true; return true;
} }
this->SetError(result); this->SetError(result);
@ -2658,7 +2657,7 @@ bool cmFileCommand::HandleCreateLinkCommand(
<< cmSystemTools::GetLastSystemError() << "\n"; << cmSystemTools::GetLastSystemError() << "\n";
if (!arguments.Result.empty()) { if (!arguments.Result.empty()) {
this->Makefile->AddDefinition(arguments.Result, e.str().c_str()); this->Makefile->AddDefinition(arguments.Result, e.str());
return true; return true;
} }
this->SetError(e.str()); this->SetError(e.str());
@ -2693,7 +2692,7 @@ bool cmFileCommand::HandleCreateLinkCommand(
} }
if (!arguments.Result.empty()) { if (!arguments.Result.empty()) {
this->Makefile->AddDefinition(arguments.Result, result.c_str()); this->Makefile->AddDefinition(arguments.Result, result);
} }
return true; return true;
@ -2821,7 +2820,7 @@ bool cmFileCommand::HandleGetRuntimeDependenciesCommand(
std::string varName = std::string varName =
parsedArgs.ConflictingDependenciesPrefix + "_" + val.first; parsedArgs.ConflictingDependenciesPrefix + "_" + val.first;
std::string pathsStr = cmJoin(paths, ";"); std::string pathsStr = cmJoin(paths, ";");
this->Makefile->AddDefinition(varName, pathsStr.c_str()); this->Makefile->AddDefinition(varName, pathsStr);
} else { } else {
std::ostringstream e; std::ostringstream e;
e << "Multiple conflicting paths found for " << val.first << ":"; e << "Multiple conflicting paths found for " << val.first << ":";
@ -2851,18 +2850,16 @@ bool cmFileCommand::HandleGetRuntimeDependenciesCommand(
if (!parsedArgs.ResolvedDependenciesVar.empty()) { if (!parsedArgs.ResolvedDependenciesVar.empty()) {
std::string val = cmJoin(deps, ";"); std::string val = cmJoin(deps, ";");
this->Makefile->AddDefinition(parsedArgs.ResolvedDependenciesVar, this->Makefile->AddDefinition(parsedArgs.ResolvedDependenciesVar, val);
val.c_str());
} }
if (!parsedArgs.UnresolvedDependenciesVar.empty()) { if (!parsedArgs.UnresolvedDependenciesVar.empty()) {
std::string val = cmJoin(unresolvedDeps, ";"); std::string val = cmJoin(unresolvedDeps, ";");
this->Makefile->AddDefinition(parsedArgs.UnresolvedDependenciesVar, this->Makefile->AddDefinition(parsedArgs.UnresolvedDependenciesVar, val);
val.c_str());
} }
if (!parsedArgs.ConflictingDependenciesPrefix.empty()) { if (!parsedArgs.ConflictingDependenciesPrefix.empty()) {
std::string val = cmJoin(conflictingDeps, ";"); std::string val = cmJoin(conflictingDeps, ";");
this->Makefile->AddDefinition( this->Makefile->AddDefinition(
parsedArgs.ConflictingDependenciesPrefix + "_FILENAMES", val.c_str()); parsedArgs.ConflictingDependenciesPrefix + "_FILENAMES", val);
} }
return true; return true;
} }

2
Source/cmFileInstaller.cxx
View File

@ -38,7 +38,7 @@ cmFileInstaller::~cmFileInstaller()
{ {
// Save the updated install manifest. // Save the updated install manifest.
this->Makefile->AddDefinition("CMAKE_INSTALL_MANIFEST_FILES", this->Makefile->AddDefinition("CMAKE_INSTALL_MANIFEST_FILES",
this->Manifest.c_str()); this->Manifest);
} }
void cmFileInstaller::ManifestAppend(std::string const& file) void cmFileInstaller::ManifestAppend(std::string const& file)

20
Source/cmFindPackageCommand.cxx
View File

@ -675,7 +675,9 @@ void cmFindPackageCommand::AddFindDefinition(const std::string& var,
} else { } else {
this->OriginalDefs[var].exists = false; this->OriginalDefs[var].exists = false;
} }
this->Makefile->AddDefinition(var, val); if (val) {
this->Makefile->AddDefinition(var, val);
}
} }
void cmFindPackageCommand::RestoreFindDefinitions() void cmFindPackageCommand::RestoreFindDefinitions()
@ -683,7 +685,7 @@ void cmFindPackageCommand::RestoreFindDefinitions()
for (auto const& i : this->OriginalDefs) { for (auto const& i : this->OriginalDefs) {
OriginalDef const& od = i.second; OriginalDef const& od = i.second;
if (od.exists) { if (od.exists) {
this->Makefile->AddDefinition(i.first, od.value.c_str()); this->Makefile->AddDefinition(i.first, od.value);
} else { } else {
this->Makefile->RemoveDefinition(i.first); this->Makefile->RemoveDefinition(i.first);
} }
@ -957,7 +959,7 @@ bool cmFindPackageCommand::HandlePackageMode(
std::string fileVar = this->Name; std::string fileVar = this->Name;
fileVar += "_CONFIG"; fileVar += "_CONFIG";
if (found) { if (found) {
this->Makefile->AddDefinition(fileVar, this->FileFound.c_str()); this->Makefile->AddDefinition(fileVar, this->FileFound);
} else { } else {
this->Makefile->RemoveDefinition(fileVar); this->Makefile->RemoveDefinition(fileVar);
} }
@ -979,11 +981,9 @@ bool cmFindPackageCommand::HandlePackageMode(
sep = ";"; sep = ";";
} }
this->Makefile->AddDefinition(consideredConfigsVar, this->Makefile->AddDefinition(consideredConfigsVar, consideredConfigFiles);
consideredConfigFiles.c_str());
this->Makefile->AddDefinition(consideredVersionsVar, this->Makefile->AddDefinition(consideredVersionsVar, consideredVersions);
consideredVersions.c_str());
return result; return result;
} }
@ -1612,8 +1612,8 @@ bool cmFindPackageCommand::CheckVersionFile(std::string const& version_file,
this->Makefile->RemoveDefinition("PACKAGE_VERSION_EXACT"); this->Makefile->RemoveDefinition("PACKAGE_VERSION_EXACT");
// Set the input variables. // Set the input variables.
this->Makefile->AddDefinition("PACKAGE_FIND_NAME", this->Name.c_str()); this->Makefile->AddDefinition("PACKAGE_FIND_NAME", this->Name);
this->Makefile->AddDefinition("PACKAGE_FIND_VERSION", this->Version.c_str()); this->Makefile->AddDefinition("PACKAGE_FIND_VERSION", this->Version);
char buf[64]; char buf[64];
sprintf(buf, "%u", this->VersionMajor); sprintf(buf, "%u", this->VersionMajor);
this->Makefile->AddDefinition("PACKAGE_FIND_VERSION_MAJOR", buf); this->Makefile->AddDefinition("PACKAGE_FIND_VERSION_MAJOR", buf);
@ -1690,7 +1690,7 @@ void cmFindPackageCommand::StoreVersionFound()
if (this->VersionFound.empty()) { if (this->VersionFound.empty()) {
this->Makefile->RemoveDefinition(ver); this->Makefile->RemoveDefinition(ver);
} else { } else {
this->Makefile->AddDefinition(ver, this->VersionFound.c_str()); this->Makefile->AddDefinition(ver, this->VersionFound);
} }
// Store the version components. // Store the version components.

8
Source/cmForEachCommand.cxx
View File

@ -53,7 +53,7 @@ bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
for (std::string const& arg : cmMakeRange(this->Args).advance(1)) { for (std::string const& arg : cmMakeRange(this->Args).advance(1)) {
// set the variable to the loop value // set the variable to the loop value
mf.AddDefinition(this->Args[0], arg.c_str()); mf.AddDefinition(this->Args[0], arg);
// Invoke all the functions that were collected in the block. // Invoke all the functions that were collected in the block.
cmExecutionStatus status(mf); cmExecutionStatus status(mf);
for (cmListFileFunction const& func : this->Functions) { for (cmListFileFunction const& func : this->Functions) {
@ -62,12 +62,12 @@ bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
if (status.GetReturnInvoked()) { if (status.GetReturnInvoked()) {
inStatus.SetReturnInvoked(); inStatus.SetReturnInvoked();
// restore the variable to its prior value // restore the variable to its prior value
mf.AddDefinition(this->Args[0], oldDef.c_str()); mf.AddDefinition(this->Args[0], oldDef);
return true; return true;
} }
if (status.GetBreakInvoked()) { if (status.GetBreakInvoked()) {
// restore the variable to its prior value // restore the variable to its prior value
mf.AddDefinition(this->Args[0], oldDef.c_str()); mf.AddDefinition(this->Args[0], oldDef);
return true; return true;
} }
if (status.GetContinueInvoked()) { if (status.GetContinueInvoked()) {
@ -80,7 +80,7 @@ bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
} }
// restore the variable to its prior value // restore the variable to its prior value
mf.AddDefinition(this->Args[0], oldDef.c_str()); mf.AddDefinition(this->Args[0], oldDef);
return true; return true;
} }
// close out a nested foreach // close out a nested foreach

10
Source/cmFunctionCommand.cxx
View File

@ -55,20 +55,20 @@ bool cmFunctionHelperCommand::operator()(
// set the value of argc // set the value of argc
std::ostringstream strStream; std::ostringstream strStream;
strStream << expandedArgs.size(); strStream << expandedArgs.size();
makefile.AddDefinition("ARGC", strStream.str().c_str()); makefile.AddDefinition("ARGC", strStream.str());
makefile.MarkVariableAsUsed("ARGC"); makefile.MarkVariableAsUsed("ARGC");
// set the values for ARGV0 ARGV1 ... // set the values for ARGV0 ARGV1 ...
for (unsigned int t = 0; t < expandedArgs.size(); ++t) { for (unsigned int t = 0; t < expandedArgs.size(); ++t) {
std::ostringstream tmpStream; std::ostringstream tmpStream;
tmpStream << "ARGV" << t; tmpStream << "ARGV" << t;
makefile.AddDefinition(tmpStream.str(), expandedArgs[t].c_str()); makefile.AddDefinition(tmpStream.str(), expandedArgs[t]);
makefile.MarkVariableAsUsed(tmpStream.str()); makefile.MarkVariableAsUsed(tmpStream.str());
} }
// define the formal arguments // define the formal arguments
for (unsigned int j = 1; j < this->Args.size(); ++j) { for (unsigned int j = 1; j < this->Args.size(); ++j) {
makefile.AddDefinition(this->Args[j], expandedArgs[j - 1].c_str()); makefile.AddDefinition(this->Args[j], expandedArgs[j - 1]);
} }
// define ARGV and ARGN // define ARGV and ARGN
@ -76,9 +76,9 @@ bool cmFunctionHelperCommand::operator()(
std::vector<std::string>::const_iterator eit = std::vector<std::string>::const_iterator eit =
expandedArgs.begin() + (this->Args.size() - 1); expandedArgs.begin() + (this->Args.size() - 1);
std::string argnDef = cmJoin(cmMakeRange(eit, expandedArgs.end()), ";"); std::string argnDef = cmJoin(cmMakeRange(eit, expandedArgs.end()), ";");
makefile.AddDefinition("ARGV", argvDef.c_str()); makefile.AddDefinition("ARGV", argvDef);
makefile.MarkVariableAsUsed("ARGV"); makefile.MarkVariableAsUsed("ARGV");
makefile.AddDefinition("ARGN", argnDef.c_str()); makefile.AddDefinition("ARGN", argnDef);
makefile.MarkVariableAsUsed("ARGN"); makefile.MarkVariableAsUsed("ARGN");
// Invoke all the functions that were collected in the block. // Invoke all the functions that were collected in the block.

2
Source/cmGetCMakePropertyCommand.cxx
View File

@ -46,7 +46,7 @@ bool cmGetCMakePropertyCommand::InitialPass(
} }
} }
this->Makefile->AddDefinition(variable, output.c_str()); this->Makefile->AddDefinition(variable, output);
return true; return true;
} }

8
Source/cmGetDirectoryPropertyCommand.cxx
View File

@ -66,7 +66,7 @@ bool cmGetDirectoryPropertyCommand::InitialPass(
return false; return false;
} }
std::string const& output = dir->GetSafeDefinition(*i); std::string const& output = dir->GetSafeDefinition(*i);
this->Makefile->AddDefinition(variable, output.c_str()); this->Makefile->AddDefinition(variable, output);
return true; return true;
} }
@ -97,9 +97,5 @@ bool cmGetDirectoryPropertyCommand::InitialPass(
void cmGetDirectoryPropertyCommand::StoreResult(std::string const& variable, void cmGetDirectoryPropertyCommand::StoreResult(std::string const& variable,
const char* prop) const char* prop)
{ {
if (prop) { this->Makefile->AddDefinition(variable, prop ? prop : "");
this->Makefile->AddDefinition(variable, prop);
return;
}
this->Makefile->AddDefinition(variable, "");
} }

4
Source/cmGetFilenameComponentCommand.cxx
View File

@ -128,9 +128,9 @@ bool cmGetFilenameComponentCommand::InitialPass(
args[2] == "PATH" ? cmStateEnums::FILEPATH : cmStateEnums::STRING); args[2] == "PATH" ? cmStateEnums::FILEPATH : cmStateEnums::STRING);
} else { } else {
if (!programArgs.empty() && !storeArgs.empty()) { if (!programArgs.empty() && !storeArgs.empty()) {
this->Makefile->AddDefinition(storeArgs, programArgs.c_str()); this->Makefile->AddDefinition(storeArgs, programArgs);
} }
this->Makefile->AddDefinition(args.front(), result.c_str()); this->Makefile->AddDefinition(args.front(), result);
} }
return true; return true;

4
Source/cmGetPropertyCommand.cxx
View File

@ -121,7 +121,7 @@ bool cmGetPropertyCommand::InitialPass(std::vector<std::string> const& args,
} else { } else {
output = "NOTFOUND"; output = "NOTFOUND";
} }
this->Makefile->AddDefinition(this->Variable, output.c_str()); this->Makefile->AddDefinition(this->Variable, output);
} else if (this->InfoType == OutFullDoc) { } else if (this->InfoType == OutFullDoc) {
// Lookup full documentation. // Lookup full documentation.
std::string output; std::string output;
@ -132,7 +132,7 @@ bool cmGetPropertyCommand::InitialPass(std::vector<std::string> const& args,
} else { } else {
output = "NOTFOUND"; output = "NOTFOUND";
} }
this->Makefile->AddDefinition(this->Variable, output.c_str()); this->Makefile->AddDefinition(this->Variable, output);
} else if (this->InfoType == OutDefined) { } else if (this->InfoType == OutDefined) {
// Lookup if the property is defined // Lookup if the property is defined
if (this->Makefile->GetState()->GetPropertyDefinition(this->PropertyName, if (this->Makefile->GetState()->GetPropertyDefinition(this->PropertyName,

2
Source/cmGetSourceFilePropertyCommand.cxx
View File

@ -25,7 +25,7 @@ bool cmGetSourceFilePropertyCommand::InitialPass(
} }
if (sf) { if (sf) {
if (args[2] == "LANGUAGE") { if (args[2] == "LANGUAGE") {
this->Makefile->AddDefinition(var, sf->GetLanguage().c_str()); this->Makefile->AddDefinition(var, sf->GetLanguage());
return true; return true;
} }
const char* prop = nullptr; const char* prop = nullptr;

4
Source/cmGetTargetPropertyCommand.cxx
View File

@ -75,9 +75,9 @@ bool cmGetTargetPropertyCommand::InitialPass(
} }
} }
if (prop_exists) { if (prop_exists) {
this->Makefile->AddDefinition(var, prop.c_str()); this->Makefile->AddDefinition(var, prop);
return true; return true;
} }
this->Makefile->AddDefinition(var, (var + "-NOTFOUND").c_str()); this->Makefile->AddDefinition(var, var + "-NOTFOUND");
return true; return true;
} }

5
Source/cmGlobalGenerator.cxx
View File

@ -525,7 +525,7 @@ void cmGlobalGenerator::EnableLanguage(
rootBin += cmVersion::GetCMakeVersion(); rootBin += cmVersion::GetCMakeVersion();
// set the dir for parent files so they can be used by modules // set the dir for parent files so they can be used by modules
mf->AddDefinition("CMAKE_PLATFORM_INFO_DIR", rootBin.c_str()); mf->AddDefinition("CMAKE_PLATFORM_INFO_DIR", rootBin);
if (!this->CMakeInstance->GetIsInTryCompile()) { if (!this->CMakeInstance->GetIsInTryCompile()) {
// Keep a mark in the cache to indicate that we've initialized the // Keep a mark in the cache to indicate that we've initialized the
@ -585,8 +585,7 @@ void cmGlobalGenerator::EnableLanguage(
windowsVersionString << osviex.dwMajorVersion << "." windowsVersionString << osviex.dwMajorVersion << "."
<< osviex.dwMinorVersion << "." << osviex.dwMinorVersion << "."
<< osviex.dwBuildNumber; << osviex.dwBuildNumber;
mf->AddDefinition("CMAKE_HOST_SYSTEM_VERSION", mf->AddDefinition("CMAKE_HOST_SYSTEM_VERSION", windowsVersionString.str());
windowsVersionString.str().c_str());
#endif #endif
// Read the DetermineSystem file // Read the DetermineSystem file
std::string systemFile = mf->GetModulesFile("CMakeDetermineSystem.cmake"); std::string systemFile = mf->GetModulesFile("CMakeDetermineSystem.cmake");

2
Source/cmGlobalGhsMultiGenerator.cxx
View File

@ -111,7 +111,7 @@ bool cmGlobalGhsMultiGenerator::SetGeneratorToolset(std::string const& ts,
mf->AddCacheDefinition("CMAKE_MAKE_PROGRAM", gbuild.c_str(), mf->AddCacheDefinition("CMAKE_MAKE_PROGRAM", gbuild.c_str(),
"build program to use", cmStateEnums::INTERNAL, true); "build program to use", cmStateEnums::INTERNAL, true);
mf->AddDefinition("CMAKE_SYSTEM_VERSION", tsp.c_str()); mf->AddDefinition("CMAKE_SYSTEM_VERSION", tsp);
return true; return true;
} }

6
Source/cmGlobalMSYSMakefileGenerator.cxx
View File

@ -69,9 +69,9 @@ void cmGlobalMSYSMakefileGenerator::EnableLanguage(
rc = trc; rc = trc;
} }
mf->AddDefinition("MSYS", "1"); mf->AddDefinition("MSYS", "1");
mf->AddDefinition("CMAKE_GENERATOR_CC", gcc.c_str()); mf->AddDefinition("CMAKE_GENERATOR_CC", gcc);
mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx.c_str()); mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx);
mf->AddDefinition("CMAKE_GENERATOR_RC", rc.c_str()); mf->AddDefinition("CMAKE_GENERATOR_RC", rc);
this->cmGlobalUnixMakefileGenerator3::EnableLanguage(l, mf, optional); this->cmGlobalUnixMakefileGenerator3::EnableLanguage(l, mf, optional);
if (!mf->IsSet("CMAKE_AR") && !this->CMakeInstance->GetIsInTryCompile() && if (!mf->IsSet("CMAKE_AR") && !this->CMakeInstance->GetIsInTryCompile() &&

6
Source/cmGlobalMinGWMakefileGenerator.cxx
View File

@ -44,9 +44,9 @@ void cmGlobalMinGWMakefileGenerator::EnableLanguage(
if (!trc.empty()) { if (!trc.empty()) {
rc = trc; rc = trc;
} }
mf->AddDefinition("CMAKE_GENERATOR_CC", gcc.c_str()); mf->AddDefinition("CMAKE_GENERATOR_CC", gcc);
mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx.c_str()); mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx);
mf->AddDefinition("CMAKE_GENERATOR_RC", rc.c_str()); mf->AddDefinition("CMAKE_GENERATOR_RC", rc);
this->cmGlobalUnixMakefileGenerator3::EnableLanguage(l, mf, optional); this->cmGlobalUnixMakefileGenerator3::EnableLanguage(l, mf, optional);
} }

5
Source/cmGlobalVisualStudio10Generator.cxx
View File

@ -445,7 +445,7 @@ bool cmGlobalVisualStudio10Generator::InitializeSystem(cmMakefile* mf)
this->DefaultPlatformName = "Tegra-Android"; this->DefaultPlatformName = "Tegra-Android";
this->DefaultPlatformToolset = "Default"; this->DefaultPlatformToolset = "Default";
this->NsightTegraVersion = v; this->NsightTegraVersion = v;
mf->AddDefinition("CMAKE_VS_NsightTegra_VERSION", v.c_str()); mf->AddDefinition("CMAKE_VS_NsightTegra_VERSION", v);
} }
return true; return true;
@ -659,8 +659,7 @@ bool cmGlobalVisualStudio10Generator::FindMakeProgram(cmMakefile* mf)
if (!this->cmGlobalVisualStudio8Generator::FindMakeProgram(mf)) { if (!this->cmGlobalVisualStudio8Generator::FindMakeProgram(mf)) {
return false; return false;
} }
mf->AddDefinition("CMAKE_VS_MSBUILD_COMMAND", mf->AddDefinition("CMAKE_VS_MSBUILD_COMMAND", this->GetMSBuildCommand());
this->GetMSBuildCommand().c_str());
return true; return true;
} }

2
Source/cmGlobalVisualStudio14Generator.cxx
View File

@ -182,7 +182,7 @@ void cmGlobalVisualStudio14Generator::SetWindowsTargetPlatformVersion(
mf->DisplayStatus(e.str(), -1); mf->DisplayStatus(e.str(), -1);
} }
mf->AddDefinition("CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION", mf->AddDefinition("CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION",
this->WindowsTargetPlatformVersion.c_str()); this->WindowsTargetPlatformVersion);
} }
bool cmGlobalVisualStudio14Generator::SelectWindowsStoreToolset( bool cmGlobalVisualStudio14Generator::SelectWindowsStoreToolset(

5
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -121,8 +121,7 @@ bool cmGlobalVisualStudio7Generator::FindMakeProgram(cmMakefile* mf)
if (!this->cmGlobalVisualStudioGenerator::FindMakeProgram(mf)) { if (!this->cmGlobalVisualStudioGenerator::FindMakeProgram(mf)) {
return false; return false;
} }
mf->AddDefinition("CMAKE_VS_DEVENV_COMMAND", mf->AddDefinition("CMAKE_VS_DEVENV_COMMAND", this->GetDevEnvCommand());
this->GetDevEnvCommand().c_str());
return true; return true;
} }
@ -268,7 +267,7 @@ bool cmGlobalVisualStudio7Generator::SetSystemName(std::string const& s,
cmMakefile* mf) cmMakefile* mf)
{ {
mf->AddDefinition("CMAKE_VS_INTEL_Fortran_PROJECT_VERSION", mf->AddDefinition("CMAKE_VS_INTEL_Fortran_PROJECT_VERSION",
this->GetIntelProjectVersion().c_str()); this->GetIntelProjectVersion());
return this->cmGlobalVisualStudioGenerator::SetSystemName(s, mf); return this->cmGlobalVisualStudioGenerator::SetSystemName(s, mf);
} }

3
Source/cmGlobalVisualStudio8Generator.cxx
View File

@ -54,8 +54,7 @@ void cmGlobalVisualStudio8Generator::EnableLanguage(
void cmGlobalVisualStudio8Generator::AddPlatformDefinitions(cmMakefile* mf) void cmGlobalVisualStudio8Generator::AddPlatformDefinitions(cmMakefile* mf)
{ {
if (this->TargetsWindowsCE()) { if (this->TargetsWindowsCE()) {
mf->AddDefinition("CMAKE_VS_WINCE_VERSION", mf->AddDefinition("CMAKE_VS_WINCE_VERSION", this->WindowsCEVersion);
this->WindowsCEVersion.c_str());
} }
} }

6
Source/cmGlobalVisualStudioGenerator.cxx
View File

@ -57,7 +57,7 @@ void cmGlobalVisualStudioGenerator::EnableLanguage(
std::vector<std::string> const& lang, cmMakefile* mf, bool optional) std::vector<std::string> const& lang, cmMakefile* mf, bool optional)
{ {
mf->AddDefinition("CMAKE_VS_PLATFORM_NAME_DEFAULT", mf->AddDefinition("CMAKE_VS_PLATFORM_NAME_DEFAULT",
this->DefaultPlatformName.c_str()); this->DefaultPlatformName);
this->cmGlobalGenerator::EnableLanguage(lang, mf, optional); this->cmGlobalGenerator::EnableLanguage(lang, mf, optional);
} }
@ -69,7 +69,7 @@ bool cmGlobalVisualStudioGenerator::SetGeneratorPlatform(std::string const& p,
} else if (this->GetPlatformName() == "Itanium") { } else if (this->GetPlatformName() == "Itanium") {
mf->AddDefinition("CMAKE_FORCE_IA64", "TRUE"); mf->AddDefinition("CMAKE_FORCE_IA64", "TRUE");
} }
mf->AddDefinition("CMAKE_VS_PLATFORM_NAME", this->GetPlatformName().c_str()); mf->AddDefinition("CMAKE_VS_PLATFORM_NAME", this->GetPlatformName());
return this->cmGlobalGenerator::SetGeneratorPlatform(p, mf); return this->cmGlobalGenerator::SetGeneratorPlatform(p, mf);
} }
@ -488,7 +488,7 @@ bool cmGlobalVisualStudioGenerator::FindMakeProgram(cmMakefile* mf)
// directly instead of needing a helper module to do it, so we // directly instead of needing a helper module to do it, so we
// do not actually need to put CMAKE_MAKE_PROGRAM into the cache. // do not actually need to put CMAKE_MAKE_PROGRAM into the cache.
if (cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) { if (cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) {
mf->AddDefinition("CMAKE_MAKE_PROGRAM", this->GetVSMakeProgram().c_str()); mf->AddDefinition("CMAKE_MAKE_PROGRAM", this->GetVSMakeProgram());
} }
return true; return true;
} }

8
Source/cmGlobalXCodeGenerator.cxx
View File

@ -241,8 +241,7 @@ bool cmGlobalXCodeGenerator::FindMakeProgram(cmMakefile* mf)
// directly instead of needing a helper module to do it, so we // directly instead of needing a helper module to do it, so we
// do not actually need to put CMAKE_MAKE_PROGRAM into the cache. // do not actually need to put CMAKE_MAKE_PROGRAM into the cache.
if (cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) { if (cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) {
mf->AddDefinition("CMAKE_MAKE_PROGRAM", mf->AddDefinition("CMAKE_MAKE_PROGRAM", this->GetXcodeBuildCommand());
this->GetXcodeBuildCommand().c_str());
} }
return true; return true;
} }
@ -283,8 +282,7 @@ bool cmGlobalXCodeGenerator::SetGeneratorToolset(std::string const& ts,
} }
this->GeneratorToolset = ts; this->GeneratorToolset = ts;
if (!this->GeneratorToolset.empty()) { if (!this->GeneratorToolset.empty()) {
mf->AddDefinition("CMAKE_XCODE_PLATFORM_TOOLSET", mf->AddDefinition("CMAKE_XCODE_PLATFORM_TOOLSET", this->GeneratorToolset);
this->GeneratorToolset.c_str());
} }
return true; return true;
} }
@ -293,7 +291,7 @@ void cmGlobalXCodeGenerator::EnableLanguage(
std::vector<std::string> const& lang, cmMakefile* mf, bool optional) std::vector<std::string> const& lang, cmMakefile* mf, bool optional)
{ {
mf->AddDefinition("XCODE", "1"); mf->AddDefinition("XCODE", "1");
mf->AddDefinition("XCODE_VERSION", this->VersionString.c_str()); mf->AddDefinition("XCODE_VERSION", this->VersionString);
if (!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES")) { if (!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES")) {
mf->AddCacheDefinition( mf->AddCacheDefinition(
"CMAKE_CONFIGURATION_TYPES", "Debug;Release;MinSizeRel;RelWithDebInfo", "CMAKE_CONFIGURATION_TYPES", "Debug;Release;MinSizeRel;RelWithDebInfo",

38
Source/cmListCommand.cxx
View File

@ -222,7 +222,7 @@ bool cmListCommand::HandleGetCommand(std::vector<std::string> const& args)
value += varArgsExpanded[item]; value += varArgsExpanded[item];
} }
this->Makefile->AddDefinition(variableName, value.c_str()); this->Makefile->AddDefinition(variableName, value);
return true; return true;
} }
@ -246,7 +246,7 @@ bool cmListCommand::HandleAppendCommand(std::vector<std::string> const& args)
std::string::size_type(listString.empty() || args.empty()); std::string::size_type(listString.empty() || args.empty());
listString += &";"[offset] + cmJoin(cmMakeRange(args).advance(2), ";"); listString += &";"[offset] + cmJoin(cmMakeRange(args).advance(2), ";");
this->Makefile->AddDefinition(listName, listString.c_str()); this->Makefile->AddDefinition(listName, listString);
return true; return true;
} }
@ -271,7 +271,7 @@ bool cmListCommand::HandlePrependCommand(std::vector<std::string> const& args)
listString.insert(0, listString.insert(0,
cmJoin(cmMakeRange(args).advance(2), ";") + &";"[offset]); cmJoin(cmMakeRange(args).advance(2), ";") + &";"[offset]);
this->Makefile->AddDefinition(listName, listString.c_str()); this->Makefile->AddDefinition(listName, listString);
return true; return true;
} }
@ -299,7 +299,7 @@ bool cmListCommand::HandlePopBackCommand(std::vector<std::string> const& args)
// Ok, assign elements to be removed to the given variables // Ok, assign elements to be removed to the given variables
for (; !varArgsExpanded.empty() && ai != args.cend(); ++ai) { for (; !varArgsExpanded.empty() && ai != args.cend(); ++ai) {
assert(!ai->empty()); assert(!ai->empty());
this->Makefile->AddDefinition(*ai, varArgsExpanded.back().c_str()); this->Makefile->AddDefinition(*ai, varArgsExpanded.back());
varArgsExpanded.pop_back(); varArgsExpanded.pop_back();
} }
// Undefine the rest variables if the list gets empty earlier... // Undefine the rest variables if the list gets empty earlier...
@ -308,8 +308,7 @@ bool cmListCommand::HandlePopBackCommand(std::vector<std::string> const& args)
} }
} }
this->Makefile->AddDefinition(listName, this->Makefile->AddDefinition(listName, cmJoin(varArgsExpanded, ";"));
cmJoin(varArgsExpanded, ";").c_str());
} else if (ai != } else if (ai !=
args.cend()) { // The list is empty, but some args were given args.cend()) { // The list is empty, but some args were given
@ -347,7 +346,7 @@ bool cmListCommand::HandlePopFrontCommand(std::vector<std::string> const& args)
auto vi = varArgsExpanded.begin(); auto vi = varArgsExpanded.begin();
for (; vi != varArgsExpanded.end() && ai != args.cend(); ++ai, ++vi) { for (; vi != varArgsExpanded.end() && ai != args.cend(); ++ai, ++vi) {
assert(!ai->empty()); assert(!ai->empty());
this->Makefile->AddDefinition(*ai, vi->c_str()); this->Makefile->AddDefinition(*ai, *vi);
} }
varArgsExpanded.erase(varArgsExpanded.begin(), vi); varArgsExpanded.erase(varArgsExpanded.begin(), vi);
// Undefine the rest variables if the list gets empty earlier... // Undefine the rest variables if the list gets empty earlier...
@ -356,8 +355,7 @@ bool cmListCommand::HandlePopFrontCommand(std::vector<std::string> const& args)
} }
} }
this->Makefile->AddDefinition(listName, this->Makefile->AddDefinition(listName, cmJoin(varArgsExpanded, ";"));
cmJoin(varArgsExpanded, ";").c_str());
} else if (ai != } else if (ai !=
args.cend()) { // The list is empty, but some args were given args.cend()) { // The list is empty, but some args were given
@ -391,7 +389,7 @@ bool cmListCommand::HandleFindCommand(std::vector<std::string> const& args)
if (it != varArgsExpanded.end()) { if (it != varArgsExpanded.end()) {
std::ostringstream indexStream; std::ostringstream indexStream;
indexStream << std::distance(varArgsExpanded.begin(), it); indexStream << std::distance(varArgsExpanded.begin(), it);
this->Makefile->AddDefinition(variableName, indexStream.str().c_str()); this->Makefile->AddDefinition(variableName, indexStream.str());
return true; return true;
} }
@ -437,7 +435,7 @@ bool cmListCommand::HandleInsertCommand(std::vector<std::string> const& args)
args.end()); args.end());
std::string value = cmJoin(varArgsExpanded, ";"); std::string value = cmJoin(varArgsExpanded, ";");
this->Makefile->AddDefinition(listName, value.c_str()); this->Makefile->AddDefinition(listName, value);
return true; return true;
} }
@ -465,7 +463,7 @@ bool cmListCommand::HandleJoinCommand(std::vector<std::string> const& args)
std::string value = std::string value =
cmJoin(cmMakeRange(varArgsExpanded.begin(), varArgsExpanded.end()), glue); cmJoin(cmMakeRange(varArgsExpanded.begin(), varArgsExpanded.end()), glue);
this->Makefile->AddDefinition(variableName, value.c_str()); this->Makefile->AddDefinition(variableName, value);
return true; return true;
} }
@ -494,7 +492,7 @@ bool cmListCommand::HandleRemoveItemCommand(
cmRemoveMatching(varArgsExpanded, cmMakeRange(remBegin, remEnd)); cmRemoveMatching(varArgsExpanded, cmMakeRange(remBegin, remEnd));
std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin(); std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin();
std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";"); std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";");
this->Makefile->AddDefinition(listName, value.c_str()); this->Makefile->AddDefinition(listName, value);
return true; return true;
} }
@ -515,7 +513,7 @@ bool cmListCommand::HandleReverseCommand(std::vector<std::string> const& args)
std::string value = cmJoin(cmReverseRange(varArgsExpanded), ";"); std::string value = cmJoin(cmReverseRange(varArgsExpanded), ";");
this->Makefile->AddDefinition(listName, value.c_str()); this->Makefile->AddDefinition(listName, value);
return true; return true;
} }
@ -540,7 +538,7 @@ bool cmListCommand::HandleRemoveDuplicatesCommand(
std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin(); std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin();
std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";"); std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";");
this->Makefile->AddDefinition(listName, value.c_str()); this->Makefile->AddDefinition(listName, value);
return true; return true;
} }
@ -1091,7 +1089,7 @@ bool cmListCommand::HandleTransformCommand(
} }
this->Makefile->AddDefinition(command.OutputName, this->Makefile->AddDefinition(command.OutputName,
cmJoin(varArgsExpanded, ";").c_str()); cmJoin(varArgsExpanded, ";"));
return true; return true;
} }
@ -1300,7 +1298,7 @@ bool cmListCommand::HandleSortCommand(std::vector<std::string> const& args)
} }
std::string value = cmJoin(varArgsExpanded, ";"); std::string value = cmJoin(varArgsExpanded, ";");
this->Makefile->AddDefinition(listName, value.c_str()); this->Makefile->AddDefinition(listName, value);
return true; return true;
} }
@ -1349,7 +1347,7 @@ bool cmListCommand::HandleSublistCommand(std::vector<std::string> const& args)
: size_type(start + length); : size_type(start + length);
std::vector<std::string> sublist(varArgsExpanded.begin() + start, std::vector<std::string> sublist(varArgsExpanded.begin() + start,
varArgsExpanded.begin() + end); varArgsExpanded.begin() + end);
this->Makefile->AddDefinition(variableName, cmJoin(sublist, ";").c_str()); this->Makefile->AddDefinition(variableName, cmJoin(sublist, ";"));
return true; return true;
} }
@ -1406,7 +1404,7 @@ bool cmListCommand::HandleRemoveAtCommand(std::vector<std::string> const& args)
std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin(); std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin();
std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";"); std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";");
this->Makefile->AddDefinition(listName, value.c_str()); this->Makefile->AddDefinition(listName, value);
return true; return true;
} }
@ -1500,6 +1498,6 @@ bool cmListCommand::FilterRegex(std::vector<std::string> const& args,
std::remove_if(argsBegin, argsEnd, MatchesRegex(regex, includeMatches)); std::remove_if(argsBegin, argsEnd, MatchesRegex(regex, includeMatches));
std::string value = cmJoin(cmMakeRange(argsBegin, newArgsEnd), ";"); std::string value = cmJoin(cmMakeRange(argsBegin, newArgsEnd), ";");
this->Makefile->AddDefinition(listName, value.c_str()); this->Makefile->AddDefinition(listName, value);
return true; return true;
} }

2
Source/cmLoadCacheCommand.cxx
View File

@ -153,7 +153,7 @@ void cmLoadCacheCommand::CheckLine(const char* line)
// prefix. // prefix.
var = this->Prefix + var; var = this->Prefix + var;
if (!value.empty()) { if (!value.empty()) {
this->Makefile->AddDefinition(var, value.c_str()); this->Makefile->AddDefinition(var, value);
} else { } else {
this->Makefile->RemoveDefinition(var); this->Makefile->RemoveDefinition(var);
} }

2
Source/cmLoadCommandCommand.cxx
View File

@ -230,7 +230,7 @@ bool cmLoadCommandCommand::InitialPass(std::vector<std::string> const& args,
} }
// Report what file was loaded for this command. // Report what file was loaded for this command.
this->Makefile->AddDefinition(reportVar, fullPath.c_str()); this->Makefile->AddDefinition(reportVar, fullPath);
// find the init function // find the init function
std::string initFuncName = args[0] + "Init"; std::string initFuncName = args[0] + "Init";

4
Source/cmLocalGenerator.cxx
View File

@ -2973,7 +2973,7 @@ void cmLocalGenerator::GenerateAppleInfoPList(cmGeneratorTarget* target,
// back to the directory-level values set by the user. // back to the directory-level values set by the user.
cmMakefile* mf = this->Makefile; cmMakefile* mf = this->Makefile;
cmMakefile::ScopePushPop varScope(mf); cmMakefile::ScopePushPop varScope(mf);
mf->AddDefinition("MACOSX_BUNDLE_EXECUTABLE_NAME", targetName.c_str()); mf->AddDefinition("MACOSX_BUNDLE_EXECUTABLE_NAME", targetName);
cmLGInfoProp(mf, target, "MACOSX_BUNDLE_INFO_STRING"); cmLGInfoProp(mf, target, "MACOSX_BUNDLE_INFO_STRING");
cmLGInfoProp(mf, target, "MACOSX_BUNDLE_ICON_FILE"); cmLGInfoProp(mf, target, "MACOSX_BUNDLE_ICON_FILE");
cmLGInfoProp(mf, target, "MACOSX_BUNDLE_GUI_IDENTIFIER"); cmLGInfoProp(mf, target, "MACOSX_BUNDLE_GUI_IDENTIFIER");
@ -3012,7 +3012,7 @@ void cmLocalGenerator::GenerateFrameworkInfoPList(
// back to the directory-level values set by the user. // back to the directory-level values set by the user.
cmMakefile* mf = this->Makefile; cmMakefile* mf = this->Makefile;
cmMakefile::ScopePushPop varScope(mf); cmMakefile::ScopePushPop varScope(mf);
mf->AddDefinition("MACOSX_FRAMEWORK_NAME", targetName.c_str()); mf->AddDefinition("MACOSX_FRAMEWORK_NAME", targetName);
cmLGInfoProp(mf, target, "MACOSX_FRAMEWORK_ICON_FILE"); cmLGInfoProp(mf, target, "MACOSX_FRAMEWORK_ICON_FILE");
cmLGInfoProp(mf, target, "MACOSX_FRAMEWORK_IDENTIFIER"); cmLGInfoProp(mf, target, "MACOSX_FRAMEWORK_IDENTIFIER");
cmLGInfoProp(mf, target, "MACOSX_FRAMEWORK_SHORT_VERSION_STRING"); cmLGInfoProp(mf, target, "MACOSX_FRAMEWORK_SHORT_VERSION_STRING");

38
Source/cmMakefile.cxx
View File

@ -557,8 +557,9 @@ void cmMakefile::IncludeScope::EnforceCMP0011()
bool cmMakefile::ReadDependentFile(const std::string& filename, bool cmMakefile::ReadDependentFile(const std::string& filename,
bool noPolicyScope) bool noPolicyScope)
{ {
this->AddDefinition("CMAKE_PARENT_LIST_FILE", if (const char* def = this->GetDefinition("CMAKE_CURRENT_LIST_FILE")) {
this->GetDefinition("CMAKE_CURRENT_LIST_FILE")); this->AddDefinition("CMAKE_PARENT_LIST_FILE", def);
}
std::string filenametoread = cmSystemTools::CollapseFullPath( std::string filenametoread = cmSystemTools::CollapseFullPath(
filename, this->GetCurrentSourceDirectory()); filename, this->GetCurrentSourceDirectory());
@ -641,9 +642,9 @@ void cmMakefile::ReadListFile(cmListFile const& listFile,
this->GetSafeDefinition("CMAKE_PARENT_LIST_FILE"); this->GetSafeDefinition("CMAKE_PARENT_LIST_FILE");
std::string currentFile = this->GetSafeDefinition("CMAKE_CURRENT_LIST_FILE"); std::string currentFile = this->GetSafeDefinition("CMAKE_CURRENT_LIST_FILE");
this->AddDefinition("CMAKE_CURRENT_LIST_FILE", filenametoread.c_str()); this->AddDefinition("CMAKE_CURRENT_LIST_FILE", filenametoread);
this->AddDefinition("CMAKE_CURRENT_LIST_DIR", this->AddDefinition("CMAKE_CURRENT_LIST_DIR",
cmSystemTools::GetFilenamePath(filenametoread).c_str()); cmSystemTools::GetFilenamePath(filenametoread));
this->MarkVariableAsUsed("CMAKE_PARENT_LIST_FILE"); this->MarkVariableAsUsed("CMAKE_PARENT_LIST_FILE");
this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_FILE"); this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_FILE");
@ -664,10 +665,10 @@ void cmMakefile::ReadListFile(cmListFile const& listFile,
} }
this->CheckForUnusedVariables(); this->CheckForUnusedVariables();
this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentParentFile.c_str()); this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentParentFile);
this->AddDefinition("CMAKE_CURRENT_LIST_FILE", currentFile.c_str()); this->AddDefinition("CMAKE_CURRENT_LIST_FILE", currentFile);
this->AddDefinition("CMAKE_CURRENT_LIST_DIR", this->AddDefinition("CMAKE_CURRENT_LIST_DIR",
cmSystemTools::GetFilenamePath(currentFile).c_str()); cmSystemTools::GetFilenamePath(currentFile));
this->MarkVariableAsUsed("CMAKE_PARENT_LIST_FILE"); this->MarkVariableAsUsed("CMAKE_PARENT_LIST_FILE");
this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_FILE"); this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_FILE");
this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_DIR"); this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_DIR");
@ -1535,7 +1536,7 @@ void cmMakefile::Configure()
cmSystemTools::MakeDirectory(filesDir); cmSystemTools::MakeDirectory(filesDir);
assert(cmSystemTools::FileExists(currentStart, true)); assert(cmSystemTools::FileExists(currentStart, true));
this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentStart.c_str()); this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentStart);
cmListFile listFile; cmListFile listFile;
if (!listFile.ParseFile(currentStart.c_str(), this->GetMessenger(), if (!listFile.ParseFile(currentStart.c_str(), this->GetMessenger(),
@ -1783,12 +1784,8 @@ void cmMakefile::AddSystemIncludeDirectories(const std::set<std::string>& incs)
} }
} }
void cmMakefile::AddDefinition(const std::string& name, const char* value) void cmMakefile::AddDefinition(const std::string& name, cm::string_view value)
{ {
if (!value) {
return;
}
if (this->VariableInitialized(name)) { if (this->VariableInitialized(name)) {
this->LogUnused("changing definition", name); this->LogUnused("changing definition", name);
} }
@ -1798,7 +1795,7 @@ void cmMakefile::AddDefinition(const std::string& name, const char* value)
cmVariableWatch* vv = this->GetVariableWatch(); cmVariableWatch* vv = this->GetVariableWatch();
if (vv) { if (vv) {
vv->VariableAccessed(name, cmVariableWatch::VARIABLE_MODIFIED_ACCESS, vv->VariableAccessed(name, cmVariableWatch::VARIABLE_MODIFIED_ACCESS,
value, this); value.data(), this);
} }
#endif #endif
} }
@ -3273,20 +3270,20 @@ std::string const& cmMakefile::GetHomeOutputDirectory() const
void cmMakefile::SetScriptModeFile(std::string const& scriptfile) void cmMakefile::SetScriptModeFile(std::string const& scriptfile)
{ {
this->AddDefinition("CMAKE_SCRIPT_MODE_FILE", scriptfile.c_str()); this->AddDefinition("CMAKE_SCRIPT_MODE_FILE", scriptfile);
} }
void cmMakefile::SetArgcArgv(const std::vector<std::string>& args) void cmMakefile::SetArgcArgv(const std::vector<std::string>& args)
{ {
std::ostringstream strStream; std::ostringstream strStream;
strStream << args.size(); strStream << args.size();
this->AddDefinition("CMAKE_ARGC", strStream.str().c_str()); this->AddDefinition("CMAKE_ARGC", strStream.str());
// this->MarkVariableAsUsed("CMAKE_ARGC"); // this->MarkVariableAsUsed("CMAKE_ARGC");
for (unsigned int t = 0; t < args.size(); ++t) { for (unsigned int t = 0; t < args.size(); ++t) {
std::ostringstream tmpStream; std::ostringstream tmpStream;
tmpStream << "CMAKE_ARGV" << t; tmpStream << "CMAKE_ARGV" << t;
this->AddDefinition(tmpStream.str(), args[t].c_str()); this->AddDefinition(tmpStream.str(), args[t]);
// this->MarkVariableAsUsed(tmpStream.str().c_str()); // this->MarkVariableAsUsed(tmpStream.str().c_str());
} }
} }
@ -3367,8 +3364,9 @@ void cmMakefile::AddTargetObject(std::string const& tgtName,
void cmMakefile::EnableLanguage(std::vector<std::string> const& lang, void cmMakefile::EnableLanguage(std::vector<std::string> const& lang,
bool optional) bool optional)
{ {
this->AddDefinition("CMAKE_CFG_INTDIR", if (const char* def = this->GetGlobalGenerator()->GetCMakeCFGIntDir()) {
this->GetGlobalGenerator()->GetCMakeCFGIntDir()); this->AddDefinition("CMAKE_CFG_INTDIR", def);
}
// If RC is explicitly listed we need to do it after other languages. // If RC is explicitly listed we need to do it after other languages.
// On some platforms we enable RC implicitly while enabling others. // On some platforms we enable RC implicitly while enabling others.
// Do not let that look like recursive enable_language(RC). // Do not let that look like recursive enable_language(RC).
@ -4220,7 +4218,7 @@ void cmMakefile::StoreMatches(cmsys::RegularExpression& re)
std::string const& m = re.match(i); std::string const& m = re.match(i);
if (!m.empty()) { if (!m.empty()) {
std::string const& var = matchVariables[i]; std::string const& var = matchVariables[i];
this->AddDefinition(var, m.c_str()); this->AddDefinition(var, m);
this->MarkVariableAsUsed(var); this->MarkVariableAsUsed(var);
highest = static_cast<char>('0' + i); highest = static_cast<char>('0' + i);
} }

6
Source/cmMakefile.h
View File

@ -17,6 +17,8 @@
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include "cm_string_view.hxx"
#include "cmAlgorithms.h" #include "cmAlgorithms.h"
#include "cmFunctionBlocker.h" #include "cmFunctionBlocker.h"
#include "cmListFileCache.h" #include "cmListFileCache.h"
@ -263,11 +265,11 @@ public:
* Add a variable definition to the build. This variable * Add a variable definition to the build. This variable
* can be used in CMake to refer to lists, directories, etc. * can be used in CMake to refer to lists, directories, etc.
*/ */
void AddDefinition(const std::string& name, const char* value); void AddDefinition(const std::string& name, cm::string_view value);
/** /**
* Add bool variable definition to the build. * Add bool variable definition to the build.
*/ */
void AddDefinitionBool(const std::string& name, bool value); void AddDefinitionBool(const std::string& name, bool);
//! Add a definition to this makefile and the global cmake cache. //! Add a definition to this makefile and the global cmake cache.
void AddCacheDefinition(const std::string& name, const char* value, void AddCacheDefinition(const std::string& name, const char* value,
const char* doc, cmStateEnums::CacheEntryType type, const char* doc, cmStateEnums::CacheEntryType type,

11
Source/cmParseArgumentsCommand.cxx
View File

@ -75,7 +75,7 @@ static void PassParsedArguments(
for (auto const& iter : singleValArgs) { for (auto const& iter : singleValArgs) {
if (!iter.second.empty()) { if (!iter.second.empty()) {
makefile.AddDefinition(prefix + iter.first, iter.second.c_str()); makefile.AddDefinition(prefix + iter.first, iter.second);
} else { } else {
makefile.RemoveDefinition(prefix + iter.first); makefile.RemoveDefinition(prefix + iter.first);
} }
@ -84,7 +84,7 @@ static void PassParsedArguments(
for (auto const& iter : multiValArgs) { for (auto const& iter : multiValArgs) {
if (!iter.second.empty()) { if (!iter.second.empty()) {
makefile.AddDefinition(prefix + iter.first, makefile.AddDefinition(prefix + iter.first,
JoinList(iter.second, parseFromArgV).c_str()); JoinList(iter.second, parseFromArgV));
} else { } else {
makefile.RemoveDefinition(prefix + iter.first); makefile.RemoveDefinition(prefix + iter.first);
} }
@ -92,15 +92,14 @@ static void PassParsedArguments(
if (!unparsed.empty()) { if (!unparsed.empty()) {
makefile.AddDefinition(prefix + "UNPARSED_ARGUMENTS", makefile.AddDefinition(prefix + "UNPARSED_ARGUMENTS",
JoinList(unparsed, parseFromArgV).c_str()); JoinList(unparsed, parseFromArgV));
} else { } else {
makefile.RemoveDefinition(prefix + "UNPARSED_ARGUMENTS"); makefile.RemoveDefinition(prefix + "UNPARSED_ARGUMENTS");
} }
if (!keywordsMissingValues.empty()) { if (!keywordsMissingValues.empty()) {
makefile.AddDefinition( makefile.AddDefinition(prefix + "KEYWORDS_MISSING_VALUES",
prefix + "KEYWORDS_MISSING_VALUES", cmJoin(cmMakeRange(keywordsMissingValues), ";"));
cmJoin(cmMakeRange(keywordsMissingValues), ";").c_str());
} else { } else {
makefile.RemoveDefinition(prefix + "KEYWORDS_MISSING_VALUES"); makefile.RemoveDefinition(prefix + "KEYWORDS_MISSING_VALUES");
} }

42
Source/cmProjectCommand.cxx
View File

@ -45,12 +45,12 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args,
this->Makefile->GetCurrentSourceDirectory().c_str(), this->Makefile->GetCurrentSourceDirectory().c_str(),
"Value Computed by CMake", cmStateEnums::STATIC); "Value Computed by CMake", cmStateEnums::STATIC);
this->Makefile->AddDefinition( this->Makefile->AddDefinition("PROJECT_BINARY_DIR",
"PROJECT_BINARY_DIR", this->Makefile->GetCurrentBinaryDirectory().c_str()); this->Makefile->GetCurrentBinaryDirectory());
this->Makefile->AddDefinition( this->Makefile->AddDefinition("PROJECT_SOURCE_DIR",
"PROJECT_SOURCE_DIR", this->Makefile->GetCurrentSourceDirectory().c_str()); this->Makefile->GetCurrentSourceDirectory());
this->Makefile->AddDefinition("PROJECT_NAME", projectName.c_str()); this->Makefile->AddDefinition("PROJECT_NAME", projectName);
// Set the CMAKE_PROJECT_NAME variable to be the highest-level // Set the CMAKE_PROJECT_NAME variable to be the highest-level
// project name in the tree. If there are two project commands // project name in the tree. If there are two project commands
@ -60,7 +60,7 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args,
// will work. // will work.
if (!this->Makefile->GetDefinition("CMAKE_PROJECT_NAME") || if (!this->Makefile->GetDefinition("CMAKE_PROJECT_NAME") ||
(this->Makefile->IsRootMakefile())) { (this->Makefile->IsRootMakefile())) {
this->Makefile->AddDefinition("CMAKE_PROJECT_NAME", projectName.c_str()); this->Makefile->AddDefinition("CMAKE_PROJECT_NAME", projectName);
this->Makefile->AddCacheDefinition( this->Makefile->AddCacheDefinition(
"CMAKE_PROJECT_NAME", projectName.c_str(), "Value Computed by CMake", "CMAKE_PROJECT_NAME", projectName.c_str(), "Value Computed by CMake",
cmStateEnums::STATIC); cmStateEnums::STATIC);
@ -258,24 +258,24 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args,
std::string vv; std::string vv;
vv = projectName + "_VERSION"; vv = projectName + "_VERSION";
this->Makefile->AddDefinition("PROJECT_VERSION", version_string.c_str()); this->Makefile->AddDefinition("PROJECT_VERSION", version_string);
this->Makefile->AddDefinition(vv, version_string.c_str()); this->Makefile->AddDefinition(vv, version_string);
vv = projectName + "_VERSION_MAJOR"; vv = projectName + "_VERSION_MAJOR";
this->Makefile->AddDefinition("PROJECT_VERSION_MAJOR", this->Makefile->AddDefinition("PROJECT_VERSION_MAJOR",
version_components[0].c_str()); version_components[0]);
this->Makefile->AddDefinition(vv, version_components[0].c_str()); this->Makefile->AddDefinition(vv, version_components[0]);
vv = projectName + "_VERSION_MINOR"; vv = projectName + "_VERSION_MINOR";
this->Makefile->AddDefinition("PROJECT_VERSION_MINOR", this->Makefile->AddDefinition("PROJECT_VERSION_MINOR",
version_components[1].c_str()); version_components[1]);
this->Makefile->AddDefinition(vv, version_components[1].c_str()); this->Makefile->AddDefinition(vv, version_components[1]);
vv = projectName + "_VERSION_PATCH"; vv = projectName + "_VERSION_PATCH";
this->Makefile->AddDefinition("PROJECT_VERSION_PATCH", this->Makefile->AddDefinition("PROJECT_VERSION_PATCH",
version_components[2].c_str()); version_components[2]);
this->Makefile->AddDefinition(vv, version_components[2].c_str()); this->Makefile->AddDefinition(vv, version_components[2]);
vv = projectName + "_VERSION_TWEAK"; vv = projectName + "_VERSION_TWEAK";
this->Makefile->AddDefinition("PROJECT_VERSION_TWEAK", this->Makefile->AddDefinition("PROJECT_VERSION_TWEAK",
version_components[3].c_str()); version_components[3]);
this->Makefile->AddDefinition(vv, version_components[3].c_str()); this->Makefile->AddDefinition(vv, version_components[3]);
// Also, try set top level variables // Also, try set top level variables
TopLevelCMakeVarCondSet("CMAKE_PROJECT_VERSION", version_string.c_str()); TopLevelCMakeVarCondSet("CMAKE_PROJECT_VERSION", version_string.c_str());
TopLevelCMakeVarCondSet("CMAKE_PROJECT_VERSION_MAJOR", TopLevelCMakeVarCondSet("CMAKE_PROJECT_VERSION_MAJOR",
@ -327,14 +327,12 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args,
} }
} }
this->Makefile->AddDefinition("PROJECT_DESCRIPTION", description.c_str()); this->Makefile->AddDefinition("PROJECT_DESCRIPTION", description);
this->Makefile->AddDefinition(projectName + "_DESCRIPTION", this->Makefile->AddDefinition(projectName + "_DESCRIPTION", description);
description.c_str());
TopLevelCMakeVarCondSet("CMAKE_PROJECT_DESCRIPTION", description.c_str()); TopLevelCMakeVarCondSet("CMAKE_PROJECT_DESCRIPTION", description.c_str());
this->Makefile->AddDefinition("PROJECT_HOMEPAGE_URL", homepage.c_str()); this->Makefile->AddDefinition("PROJECT_HOMEPAGE_URL", homepage);
this->Makefile->AddDefinition(projectName + "_HOMEPAGE_URL", this->Makefile->AddDefinition(projectName + "_HOMEPAGE_URL", homepage);
homepage.c_str());
TopLevelCMakeVarCondSet("CMAKE_PROJECT_HOMEPAGE_URL", homepage.c_str()); TopLevelCMakeVarCondSet("CMAKE_PROJECT_HOMEPAGE_URL", homepage.c_str());
if (languages.empty()) { if (languages.empty()) {

2
Source/cmQTWrapCPPCommand.cxx
View File

@ -89,6 +89,6 @@ bool cmQTWrapCPPCommand::InitialPass(std::vector<std::string> const& args,
} }
// Store the final list of source files. // Store the final list of source files.
this->Makefile->AddDefinition(sourceList, sourceListValue.c_str()); this->Makefile->AddDefinition(sourceList, sourceListValue);
return true; return true;
} }

4
Source/cmQTWrapUICommand.cxx
View File

@ -132,7 +132,7 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& args,
} }
// Store the final list of source files and headers. // Store the final list of source files and headers.
this->Makefile->AddDefinition(sourceList, sourceListValue.c_str()); this->Makefile->AddDefinition(sourceList, sourceListValue);
this->Makefile->AddDefinition(headerList, headerListValue.c_str()); this->Makefile->AddDefinition(headerList, headerListValue);
return true; return true;
} }

2
Source/cmRemoveCommand.cxx
View File

@ -52,7 +52,7 @@ bool cmRemoveCommand::InitialPass(std::vector<std::string> const& args,
} }
// add the definition // add the definition
this->Makefile->AddDefinition(variable, value.c_str()); this->Makefile->AddDefinition(variable, value);
return true; return true;
} }

4
Source/cmSeparateArgumentsCommand.cxx
View File

@ -69,7 +69,7 @@ bool cmSeparateArgumentsCommand::InitialPass(
if (const char* def = this->Makefile->GetDefinition(var)) { if (const char* def = this->Makefile->GetDefinition(var)) {
std::string value = def; std::string value = def;
std::replace(value.begin(), value.end(), ' ', ';'); std::replace(value.begin(), value.end(), ' ', ';');
this->Makefile->AddDefinition(var, value.c_str()); this->Makefile->AddDefinition(var, value);
} }
} else { } else {
// Parse the command line. // Parse the command line.
@ -97,7 +97,7 @@ bool cmSeparateArgumentsCommand::InitialPass(
value += si; value += si;
} }
} }
this->Makefile->AddDefinition(var, value.c_str()); this->Makefile->AddDefinition(var, value);
} }
return true; return true;

2
Source/cmSetCommand.cxx
View File

@ -154,7 +154,7 @@ bool cmSetCommand::InitialPass(std::vector<std::string> const& args,
type, force); type, force);
} else { } else {
// add the definition // add the definition
this->Makefile->AddDefinition(variable, value.c_str()); this->Makefile->AddDefinition(variable, value);
} }
return true; return true;
} }

41
Source/cmStringCommand.cxx
View File

@ -123,7 +123,7 @@ bool cmStringCommand::HandleHashCommand(std::vector<std::string> const& args)
std::unique_ptr<cmCryptoHash> hash(cmCryptoHash::New(args[0].c_str())); std::unique_ptr<cmCryptoHash> hash(cmCryptoHash::New(args[0].c_str()));
if (hash) { if (hash) {
std::string out = hash->HashString(args[2]); std::string out = hash->HashString(args[2]);
this->Makefile->AddDefinition(args[1], out.c_str()); this->Makefile->AddDefinition(args[1], out);
return true; return true;
} }
return false; return false;
@ -153,7 +153,7 @@ bool cmStringCommand::HandleToUpperLowerCommand(
} }
// Store the output in the provided variable. // Store the output in the provided variable.
this->Makefile->AddDefinition(outvar, output.c_str()); this->Makefile->AddDefinition(outvar, output);
return true; return true;
} }
@ -179,7 +179,7 @@ bool cmStringCommand::HandleAsciiCommand(std::vector<std::string> const& args)
} }
} }
// Store the output in the provided variable. // Store the output in the provided variable.
this->Makefile->AddDefinition(outvar, output.c_str()); this->Makefile->AddDefinition(outvar, output);
return true; return true;
} }
@ -216,7 +216,7 @@ bool cmStringCommand::HandleConfigureCommand(
this->Makefile->ConfigureString(args[1], output, atOnly, escapeQuotes); this->Makefile->ConfigureString(args[1], output, atOnly, escapeQuotes);
// Store the output in the provided variable. // Store the output in the provided variable.
this->Makefile->AddDefinition(args[2], output.c_str()); this->Makefile->AddDefinition(args[2], output);
return true; return true;
} }
@ -295,7 +295,7 @@ bool cmStringCommand::RegexMatch(std::vector<std::string> const& args)
} }
// Store the output in the provided variable. // Store the output in the provided variable.
this->Makefile->AddDefinition(outvar, output.c_str()); this->Makefile->AddDefinition(outvar, output);
return true; return true;
} }
@ -342,7 +342,7 @@ bool cmStringCommand::RegexMatchAll(std::vector<std::string> const& args)
} }
// Store the output in the provided variable. // Store the output in the provided variable.
this->Makefile->AddDefinition(outvar, output.c_str()); this->Makefile->AddDefinition(outvar, output);
return true; return true;
} }
@ -383,7 +383,7 @@ bool cmStringCommand::RegexReplace(std::vector<std::string> const& args)
} }
// Store the output in the provided variable. // Store the output in the provided variable.
this->Makefile->AddDefinition(outvar, output.c_str()); this->Makefile->AddDefinition(outvar, output);
return true; return true;
} }
@ -430,7 +430,7 @@ bool cmStringCommand::HandleFindCommand(std::vector<std::string> const& args)
if (std::string::npos != pos) { if (std::string::npos != pos) {
std::ostringstream s; std::ostringstream s;
s << pos; s << pos;
this->Makefile->AddDefinition(outvar, s.str().c_str()); this->Makefile->AddDefinition(outvar, s.str());
return true; return true;
} }
@ -505,7 +505,7 @@ bool cmStringCommand::HandleReplaceCommand(
cmsys::SystemTools::ReplaceString(input, matchExpression.c_str(), cmsys::SystemTools::ReplaceString(input, matchExpression.c_str(),
replaceExpression.c_str()); replaceExpression.c_str());
this->Makefile->AddDefinition(variableName, input.c_str()); this->Makefile->AddDefinition(variableName, input);
return true; return true;
} }
@ -538,8 +538,7 @@ bool cmStringCommand::HandleSubstringCommand(
return false; return false;
} }
this->Makefile->AddDefinition(variableName, this->Makefile->AddDefinition(variableName, stringValue.substr(begin, end));
stringValue.substr(begin, end).c_str());
return true; return true;
} }
@ -581,7 +580,7 @@ bool cmStringCommand::HandleAppendCommand(std::vector<std::string> const& args)
value = oldValue; value = oldValue;
} }
value += cmJoin(cmMakeRange(args).advance(2), std::string()); value += cmJoin(cmMakeRange(args).advance(2), std::string());
this->Makefile->AddDefinition(variable, value.c_str()); this->Makefile->AddDefinition(variable, value);
return true; return true;
} }
@ -605,7 +604,7 @@ bool cmStringCommand::HandlePrependCommand(
if (oldValue) { if (oldValue) {
value += oldValue; value += oldValue;
} }
this->Makefile->AddDefinition(variable, value.c_str()); this->Makefile->AddDefinition(variable, value);
return true; return true;
} }
@ -637,7 +636,7 @@ bool cmStringCommand::joinImpl(std::vector<std::string> const& args,
// both `CONCAT` and `JOIN` sub-commands. // both `CONCAT` and `JOIN` sub-commands.
std::string value = cmJoin(cmMakeRange(args).advance(varIdx + 1), glue); std::string value = cmJoin(cmMakeRange(args).advance(varIdx + 1), glue);
this->Makefile->AddDefinition(variableName, value.c_str()); this->Makefile->AddDefinition(variableName, value);
return true; return true;
} }
@ -653,7 +652,7 @@ bool cmStringCommand::HandleMakeCIdentifierCommand(
const std::string& variableName = args[2]; const std::string& variableName = args[2];
this->Makefile->AddDefinition(variableName, this->Makefile->AddDefinition(variableName,
cmSystemTools::MakeCidentifier(input).c_str()); cmSystemTools::MakeCidentifier(input));
return true; return true;
} }
@ -672,7 +671,7 @@ bool cmStringCommand::HandleGenexStripCommand(
const std::string& variableName = args[2]; const std::string& variableName = args[2];
this->Makefile->AddDefinition(variableName, result.c_str()); this->Makefile->AddDefinition(variableName, result);
return true; return true;
} }
@ -711,8 +710,8 @@ bool cmStringCommand::HandleStripCommand(std::vector<std::string> const& args)
outLength = endPos - startPos + 1; outLength = endPos - startPos + 1;
} }
this->Makefile->AddDefinition( this->Makefile->AddDefinition(variableName,
variableName, stringValue.substr(startPos, outLength).c_str()); stringValue.substr(startPos, outLength));
return true; return true;
} }
@ -765,7 +764,7 @@ bool cmStringCommand::HandleRepeatCommand(std::vector<std::string> const& args)
break; break;
} }
this->Makefile->AddDefinition(variableName, result.c_str()); this->Makefile->AddDefinition(variableName, result);
return true; return true;
} }
@ -871,7 +870,7 @@ bool cmStringCommand::HandleTimestampCommand(
cmTimestamp timestamp; cmTimestamp timestamp;
std::string result = timestamp.CurrentTime(formatString, utcFlag); std::string result = timestamp.CurrentTime(formatString, utcFlag);
this->Makefile->AddDefinition(outputVariable, result.c_str()); this->Makefile->AddDefinition(outputVariable, result);
return true; return true;
} }
@ -954,7 +953,7 @@ bool cmStringCommand::HandleUuidCommand(std::vector<std::string> const& args)
uuid = cmSystemTools::UpperCase(uuid); uuid = cmSystemTools::UpperCase(uuid);
} }
this->Makefile->AddDefinition(outputVariable, uuid.c_str()); this->Makefile->AddDefinition(outputVariable, uuid);
return true; return true;
#else #else
std::ostringstream e; std::ostringstream e;

5
Source/cmTryRunCommand.cxx
View File

@ -137,7 +137,7 @@ bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv,
// now put the output into the variables // now put the output into the variables
if (!this->RunOutputVariable.empty()) { if (!this->RunOutputVariable.empty()) {
this->Makefile->AddDefinition(this->RunOutputVariable, this->Makefile->AddDefinition(this->RunOutputVariable,
runOutputContents.c_str()); runOutputContents);
} }
if (!this->OutputVariable.empty()) { if (!this->OutputVariable.empty()) {
@ -148,8 +148,7 @@ bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv,
if (compileOutput) { if (compileOutput) {
runOutputContents = compileOutput + runOutputContents; runOutputContents = compileOutput + runOutputContents;
} }
this->Makefile->AddDefinition(this->OutputVariable, this->Makefile->AddDefinition(this->OutputVariable, runOutputContents);
runOutputContents.c_str());
} }
} }
} }