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")) {
dir += this->GetOption("CPACK_INSTALL_PREFIX");
}
mf.AddDefinition("CMAKE_INSTALL_PREFIX", dir.c_str());
mf.AddDefinition("CMAKE_INSTALL_PREFIX", dir);
cmCPackLogger(
cmCPackLog::LOG_DEBUG,
@ -799,7 +799,7 @@ int cmCPackGenerator::InstallCMakeProject(
return 0;
}
} else {
mf.AddDefinition("CMAKE_INSTALL_PREFIX", tempInstallDirectory.c_str());
mf.AddDefinition("CMAKE_INSTALL_PREFIX", tempInstallDirectory);
if (!cmsys::SystemTools::MakeDirectory(tempInstallDirectory,
default_dir_mode)) {
@ -818,11 +818,11 @@ int cmCPackGenerator::InstallCMakeProject(
}
if (!buildConfig.empty()) {
mf.AddDefinition("BUILD_TYPE", buildConfig.c_str());
mf.AddDefinition("BUILD_TYPE", buildConfig);
}
std::string installComponentLowerCase = cmSystemTools::LowerCase(component);
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
@ -863,9 +863,8 @@ int cmCPackGenerator::InstallCMakeProject(
// forward definition of CMAKE_ABSOLUTE_DESTINATION_FILES
// to CPack (may be used by generators like CPack RPM or DEB)
// in order to transparently handle ABSOLUTE PATH
if (mf.GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES")) {
mf.AddDefinition("CPACK_ABSOLUTE_DESTINATION_FILES",
mf.GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES"));
if (const char* def = mf.GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES")) {
mf.AddDefinition("CPACK_ABSOLUTE_DESTINATION_FILES", def);
}
// 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()) {
globalMF.AddDefinition("CPACK_BUILD_CONFIG", cpackBuildConfig.c_str());
globalMF.AddDefinition("CPACK_BUILD_CONFIG", cpackBuildConfig);
}
if (cmSystemTools::FileExists(cpackConfigFile)) {
@ -292,24 +292,21 @@ int main(int argc, char const* const* argv)
}
if (!generator.empty()) {
globalMF.AddDefinition("CPACK_GENERATOR", generator.c_str());
globalMF.AddDefinition("CPACK_GENERATOR", generator);
}
if (!cpackProjectName.empty()) {
globalMF.AddDefinition("CPACK_PACKAGE_NAME", cpackProjectName.c_str());
globalMF.AddDefinition("CPACK_PACKAGE_NAME", cpackProjectName);
}
if (!cpackProjectVersion.empty()) {
globalMF.AddDefinition("CPACK_PACKAGE_VERSION",
cpackProjectVersion.c_str());
globalMF.AddDefinition("CPACK_PACKAGE_VERSION", cpackProjectVersion);
}
if (!cpackProjectVendor.empty()) {
globalMF.AddDefinition("CPACK_PACKAGE_VENDOR",
cpackProjectVendor.c_str());
globalMF.AddDefinition("CPACK_PACKAGE_VENDOR", cpackProjectVendor);
}
// if this is not empty it has been set on the command line
// go for it. Command line override values set in config file.
if (!cpackProjectDirectory.empty()) {
globalMF.AddDefinition("CPACK_PACKAGE_DIRECTORY",
cpackProjectDirectory.c_str());
globalMF.AddDefinition("CPACK_PACKAGE_DIRECTORY", cpackProjectDirectory);
}
// The value has not been set on the command line
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
if (!globalMF.IsSet("CPACK_PACKAGE_DIRECTORY")) {
globalMF.AddDefinition("CPACK_PACKAGE_DIRECTORY",
cpackProjectDirectory.c_str());
cpackProjectDirectory);
}
}
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");
@ -426,7 +423,7 @@ int main(int argc, char const* const* argv)
std::ostringstream ostr;
ostr << projVersionMajor << "." << projVersionMinor << "."
<< projVersionPatch;
mf->AddDefinition("CPACK_PACKAGE_VERSION", ostr.str().c_str());
mf->AddDefinition("CPACK_PACKAGE_VERSION", ostr.str());
}
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]) {
std::ostringstream str;
str << this->Handler->GetTotalErrors();
this->Makefile->AddDefinition(this->Values[ctb_NUMBER_ERRORS],
str.str().c_str());
this->Makefile->AddDefinition(this->Values[ctb_NUMBER_ERRORS], str.str());
}
if (this->Values[ctb_NUMBER_WARNINGS] &&
*this->Values[ctb_NUMBER_WARNINGS]) {
std::ostringstream str;
str << this->Handler->GetTotalWarnings();
this->Makefile->AddDefinition(this->Values[ctb_NUMBER_WARNINGS],
str.str().c_str());
str.str());
}
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]) {
std::ostringstream str;
str << res;
this->Makefile->AddDefinition(this->Values[ct_RETURN_VALUE],
str.str().c_str());
this->Makefile->AddDefinition(this->Values[ct_RETURN_VALUE], str.str());
}
this->ProcessAdditionalValues(handler);
// log the error message if there was an error

4
Source/CTest/cmCTestMemCheckCommand.cxx
View File

@ -3,7 +3,6 @@
#include "cmCTestMemCheckCommand.h"
#include <sstream>
#include <string>
#include <vector>
#include "cmCTest.h"
@ -47,7 +46,6 @@ void cmCTestMemCheckCommand::ProcessAdditionalValues(
if (this->Values[ctm_DEFECT_COUNT] && *this->Values[ctm_DEFECT_COUNT]) {
std::ostringstream str;
str << static_cast<cmCTestMemCheckHandler*>(handler)->GetDefectCount();
this->Makefile->AddDefinition(this->Values[ctm_DEFECT_COUNT],
str.str().c_str());
this->Makefile->AddDefinition(this->Values[ctm_DEFECT_COUNT], str.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);
std::ostringstream str;
str << ret;
this->Makefile->AddDefinition(returnVariable, str.str().c_str());
this->Makefile->AddDefinition(returnVariable, str.str());
}
}
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() -
this->ScriptStartTime);
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();
// set a variable with the path to the current script
this->Makefile->AddDefinition(
"CTEST_SCRIPT_DIRECTORY", cmSystemTools::GetFilenamePath(script).c_str());
this->Makefile->AddDefinition(
"CTEST_SCRIPT_NAME", cmSystemTools::GetFilenameName(script).c_str());
this->Makefile->AddDefinition("CTEST_SCRIPT_DIRECTORY",
cmSystemTools::GetFilenamePath(script));
this->Makefile->AddDefinition("CTEST_SCRIPT_NAME",
cmSystemTools::GetFilenameName(script));
this->Makefile->AddDefinition("CTEST_EXECUTABLE_NAME",
cmSystemTools::GetCTestCommand().c_str());
cmSystemTools::GetCTestCommand());
this->Makefile->AddDefinition("CMAKE_EXECUTABLE_NAME",
cmSystemTools::GetCMakeCommand().c_str());
cmSystemTools::GetCMakeCommand());
this->Makefile->AddDefinitionBool("CTEST_RUN_CURRENT_SCRIPT", true);
this->SetRunCurrentScript(true);
this->UpdateElapsedTime();
// add the script arg if defined
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__)
@ -398,7 +398,7 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg)
const std::map<std::string, std::string>& defs =
this->CTest->GetDefinitions();
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

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]) {
this->Makefile->AddDefinition(this->Values[cts_BUILD_ID],
this->CTest->GetBuildID().c_str());
this->CTest->GetBuildID());
}
return ret;

3
Source/CTest/cmCTestTestHandler.cxx
View File

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

2
Source/cmAuxSourceDirectoryCommand.cxx
View File

@ -74,6 +74,6 @@ bool cmAuxSourceDirectoryCommand::InitialPass(
sourceListValue += ";";
}
sourceListValue += cmJoin(files, ";");
this->Makefile->AddDefinition(args[1], sourceListValue.c_str());
this->Makefile->AddDefinition(args[1], sourceListValue);
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(
target, configuration, "", this->Makefile->IgnoreErrorsCMP0061());
this->Makefile->AddDefinition(variable, makecommand.c_str());
this->Makefile->AddDefinition(variable, makecommand);
return true;
}

2
Source/cmCMakeHostSystemInformationCommand.cxx
View File

@ -55,7 +55,7 @@ bool cmCMakeHostSystemInformationCommand::InitialPass(
result_list += value;
}
this->Makefile->AddDefinition(variable, result_list.c_str());
this->Makefile->AddDefinition(variable, result_list);
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.
this->Makefile->AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION",
version_min.c_str());
this->Makefile->AddDefinition("CMAKE_MINIMUM_REQUIRED_VERSION", version_min);
// Get the current version number.
unsigned int current_major = cmVersion::GetMajorVersion();

3
Source/cmCMakePolicyCommand.cxx
View File

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

2
Source/cmCPluginAPI.cxx
View File

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

5
Source/cmCoreTryCompile.cxx
View File

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

11
Source/cmCreateTestSourceList.cxx
View File

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

2
Source/cmFileInstaller.cxx
View File

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

18
Source/cmFindPackageCommand.cxx
View File

@ -675,15 +675,17 @@ void cmFindPackageCommand::AddFindDefinition(const std::string& var,
} else {
this->OriginalDefs[var].exists = false;
}
if (val) {
this->Makefile->AddDefinition(var, val);
}
}
void cmFindPackageCommand::RestoreFindDefinitions()
{
for (auto const& i : this->OriginalDefs) {
OriginalDef const& od = i.second;
if (od.exists) {
this->Makefile->AddDefinition(i.first, od.value.c_str());
this->Makefile->AddDefinition(i.first, od.value);
} else {
this->Makefile->RemoveDefinition(i.first);
}
@ -957,7 +959,7 @@ bool cmFindPackageCommand::HandlePackageMode(
std::string fileVar = this->Name;
fileVar += "_CONFIG";
if (found) {
this->Makefile->AddDefinition(fileVar, this->FileFound.c_str());
this->Makefile->AddDefinition(fileVar, this->FileFound);
} else {
this->Makefile->RemoveDefinition(fileVar);
}
@ -979,11 +981,9 @@ bool cmFindPackageCommand::HandlePackageMode(
sep = ";";
}
this->Makefile->AddDefinition(consideredConfigsVar,
consideredConfigFiles.c_str());
this->Makefile->AddDefinition(consideredConfigsVar, consideredConfigFiles);
this->Makefile->AddDefinition(consideredVersionsVar,
consideredVersions.c_str());
this->Makefile->AddDefinition(consideredVersionsVar, consideredVersions);
return result;
}
@ -1612,8 +1612,8 @@ bool cmFindPackageCommand::CheckVersionFile(std::string const& version_file,
this->Makefile->RemoveDefinition("PACKAGE_VERSION_EXACT");
// Set the input variables.
this->Makefile->AddDefinition("PACKAGE_FIND_NAME", this->Name.c_str());
this->Makefile->AddDefinition("PACKAGE_FIND_VERSION", this->Version.c_str());
this->Makefile->AddDefinition("PACKAGE_FIND_NAME", this->Name);
this->Makefile->AddDefinition("PACKAGE_FIND_VERSION", this->Version);
char buf[64];
sprintf(buf, "%u", this->VersionMajor);
this->Makefile->AddDefinition("PACKAGE_FIND_VERSION_MAJOR", buf);
@ -1690,7 +1690,7 @@ void cmFindPackageCommand::StoreVersionFound()
if (this->VersionFound.empty()) {
this->Makefile->RemoveDefinition(ver);
} else {
this->Makefile->AddDefinition(ver, this->VersionFound.c_str());
this->Makefile->AddDefinition(ver, this->VersionFound);
}
// 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)) {
// 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.
cmExecutionStatus status(mf);
for (cmListFileFunction const& func : this->Functions) {
@ -62,12 +62,12 @@ bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
if (status.GetReturnInvoked()) {
inStatus.SetReturnInvoked();
// restore the variable to its prior value
mf.AddDefinition(this->Args[0], oldDef.c_str());
mf.AddDefinition(this->Args[0], oldDef);
return true;
}
if (status.GetBreakInvoked()) {
// restore the variable to its prior value
mf.AddDefinition(this->Args[0], oldDef.c_str());
mf.AddDefinition(this->Args[0], oldDef);
return true;
}
if (status.GetContinueInvoked()) {
@ -80,7 +80,7 @@ bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
}
// restore the variable to its prior value
mf.AddDefinition(this->Args[0], oldDef.c_str());
mf.AddDefinition(this->Args[0], oldDef);
return true;
}
// close out a nested foreach

10
Source/cmFunctionCommand.cxx
View File

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

8
Source/cmGetDirectoryPropertyCommand.cxx
View File

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

4
Source/cmGetFilenameComponentCommand.cxx
View File

@ -128,9 +128,9 @@ bool cmGetFilenameComponentCommand::InitialPass(
args[2] == "PATH" ? cmStateEnums::FILEPATH : cmStateEnums::STRING);
} else {
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;

4
Source/cmGetPropertyCommand.cxx
View File

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

2
Source/cmGetSourceFilePropertyCommand.cxx
View File

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

4
Source/cmGetTargetPropertyCommand.cxx
View File

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

5
Source/cmGlobalGenerator.cxx
View File

@ -525,7 +525,7 @@ void cmGlobalGenerator::EnableLanguage(
rootBin += cmVersion::GetCMakeVersion();
// 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()) {
// Keep a mark in the cache to indicate that we've initialized the
@ -585,8 +585,7 @@ void cmGlobalGenerator::EnableLanguage(
windowsVersionString << osviex.dwMajorVersion << "."
<< osviex.dwMinorVersion << "."
<< osviex.dwBuildNumber;
mf->AddDefinition("CMAKE_HOST_SYSTEM_VERSION",
windowsVersionString.str().c_str());
mf->AddDefinition("CMAKE_HOST_SYSTEM_VERSION", windowsVersionString.str());
#endif
// Read the DetermineSystem file
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(),
"build program to use", cmStateEnums::INTERNAL, true);
mf->AddDefinition("CMAKE_SYSTEM_VERSION", tsp.c_str());
mf->AddDefinition("CMAKE_SYSTEM_VERSION", tsp);
return true;
}

6
Source/cmGlobalMSYSMakefileGenerator.cxx
View File

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

6
Source/cmGlobalMinGWMakefileGenerator.cxx
View File

@ -44,9 +44,9 @@ void cmGlobalMinGWMakefileGenerator::EnableLanguage(
if (!trc.empty()) {
rc = trc;
}
mf->AddDefinition("CMAKE_GENERATOR_CC", gcc.c_str());
mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx.c_str());
mf->AddDefinition("CMAKE_GENERATOR_RC", rc.c_str());
mf->AddDefinition("CMAKE_GENERATOR_CC", gcc);
mf->AddDefinition("CMAKE_GENERATOR_CXX", gxx);
mf->AddDefinition("CMAKE_GENERATOR_RC", rc);
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->DefaultPlatformToolset = "Default";
this->NsightTegraVersion = v;
mf->AddDefinition("CMAKE_VS_NsightTegra_VERSION", v.c_str());
mf->AddDefinition("CMAKE_VS_NsightTegra_VERSION", v);
}
return true;
@ -659,8 +659,7 @@ bool cmGlobalVisualStudio10Generator::FindMakeProgram(cmMakefile* mf)
if (!this->cmGlobalVisualStudio8Generator::FindMakeProgram(mf)) {
return false;
}
mf->AddDefinition("CMAKE_VS_MSBUILD_COMMAND",
this->GetMSBuildCommand().c_str());
mf->AddDefinition("CMAKE_VS_MSBUILD_COMMAND", this->GetMSBuildCommand());
return true;
}

2
Source/cmGlobalVisualStudio14Generator.cxx
View File

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

5
Source/cmGlobalVisualStudio7Generator.cxx
View File

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

3
Source/cmGlobalVisualStudio8Generator.cxx
View File

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

6
Source/cmGlobalVisualStudioGenerator.cxx
View File

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

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
// do not actually need to put CMAKE_MAKE_PROGRAM into the cache.
if (cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) {
mf->AddDefinition("CMAKE_MAKE_PROGRAM",
this->GetXcodeBuildCommand().c_str());
mf->AddDefinition("CMAKE_MAKE_PROGRAM", this->GetXcodeBuildCommand());
}
return true;
}
@ -283,8 +282,7 @@ bool cmGlobalXCodeGenerator::SetGeneratorToolset(std::string const& ts,
}
this->GeneratorToolset = ts;
if (!this->GeneratorToolset.empty()) {
mf->AddDefinition("CMAKE_XCODE_PLATFORM_TOOLSET",
this->GeneratorToolset.c_str());
mf->AddDefinition("CMAKE_XCODE_PLATFORM_TOOLSET", this->GeneratorToolset);
}
return true;
}
@ -293,7 +291,7 @@ void cmGlobalXCodeGenerator::EnableLanguage(
std::vector<std::string> const& lang, cmMakefile* mf, bool optional)
{
mf->AddDefinition("XCODE", "1");
mf->AddDefinition("XCODE_VERSION", this->VersionString.c_str());
mf->AddDefinition("XCODE_VERSION", this->VersionString);
if (!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES")) {
mf->AddCacheDefinition(
"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];
}
this->Makefile->AddDefinition(variableName, value.c_str());
this->Makefile->AddDefinition(variableName, value);
return true;
}
@ -246,7 +246,7 @@ bool cmListCommand::HandleAppendCommand(std::vector<std::string> const& args)
std::string::size_type(listString.empty() || args.empty());
listString += &";"[offset] + cmJoin(cmMakeRange(args).advance(2), ";");
this->Makefile->AddDefinition(listName, listString.c_str());
this->Makefile->AddDefinition(listName, listString);
return true;
}
@ -271,7 +271,7 @@ bool cmListCommand::HandlePrependCommand(std::vector<std::string> const& args)
listString.insert(0,
cmJoin(cmMakeRange(args).advance(2), ";") + &";"[offset]);
this->Makefile->AddDefinition(listName, listString.c_str());
this->Makefile->AddDefinition(listName, listString);
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
for (; !varArgsExpanded.empty() && ai != args.cend(); ++ai) {
assert(!ai->empty());
this->Makefile->AddDefinition(*ai, varArgsExpanded.back().c_str());
this->Makefile->AddDefinition(*ai, varArgsExpanded.back());
varArgsExpanded.pop_back();
}
// 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,
cmJoin(varArgsExpanded, ";").c_str());
this->Makefile->AddDefinition(listName, cmJoin(varArgsExpanded, ";"));
} else if (ai !=
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();
for (; vi != varArgsExpanded.end() && ai != args.cend(); ++ai, ++vi) {
assert(!ai->empty());
this->Makefile->AddDefinition(*ai, vi->c_str());
this->Makefile->AddDefinition(*ai, *vi);
}
varArgsExpanded.erase(varArgsExpanded.begin(), vi);
// 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,
cmJoin(varArgsExpanded, ";").c_str());
this->Makefile->AddDefinition(listName, cmJoin(varArgsExpanded, ";"));
} else if (ai !=
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()) {
std::ostringstream indexStream;
indexStream << std::distance(varArgsExpanded.begin(), it);
this->Makefile->AddDefinition(variableName, indexStream.str().c_str());
this->Makefile->AddDefinition(variableName, indexStream.str());
return true;
}
@ -437,7 +435,7 @@ bool cmListCommand::HandleInsertCommand(std::vector<std::string> const& args)
args.end());
std::string value = cmJoin(varArgsExpanded, ";");
this->Makefile->AddDefinition(listName, value.c_str());
this->Makefile->AddDefinition(listName, value);
return true;
}
@ -465,7 +463,7 @@ bool cmListCommand::HandleJoinCommand(std::vector<std::string> const& args)
std::string value =
cmJoin(cmMakeRange(varArgsExpanded.begin(), varArgsExpanded.end()), glue);
this->Makefile->AddDefinition(variableName, value.c_str());
this->Makefile->AddDefinition(variableName, value);
return true;
}
@ -494,7 +492,7 @@ bool cmListCommand::HandleRemoveItemCommand(
cmRemoveMatching(varArgsExpanded, cmMakeRange(remBegin, remEnd));
std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin();
std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";");
this->Makefile->AddDefinition(listName, value.c_str());
this->Makefile->AddDefinition(listName, value);
return true;
}
@ -515,7 +513,7 @@ bool cmListCommand::HandleReverseCommand(std::vector<std::string> const& args)
std::string value = cmJoin(cmReverseRange(varArgsExpanded), ";");
this->Makefile->AddDefinition(listName, value.c_str());
this->Makefile->AddDefinition(listName, value);
return true;
}
@ -540,7 +538,7 @@ bool cmListCommand::HandleRemoveDuplicatesCommand(
std::vector<std::string>::const_iterator argsBegin = varArgsExpanded.begin();
std::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";");
this->Makefile->AddDefinition(listName, value.c_str());
this->Makefile->AddDefinition(listName, value);
return true;
}
@ -1091,7 +1089,7 @@ bool cmListCommand::HandleTransformCommand(
}
this->Makefile->AddDefinition(command.OutputName,
cmJoin(varArgsExpanded, ";").c_str());
cmJoin(varArgsExpanded, ";"));
return true;
}
@ -1300,7 +1298,7 @@ bool cmListCommand::HandleSortCommand(std::vector<std::string> const& args)
}
std::string value = cmJoin(varArgsExpanded, ";");
this->Makefile->AddDefinition(listName, value.c_str());
this->Makefile->AddDefinition(listName, value);
return true;
}
@ -1349,7 +1347,7 @@ bool cmListCommand::HandleSublistCommand(std::vector<std::string> const& args)
: size_type(start + length);
std::vector<std::string> sublist(varArgsExpanded.begin() + start,
varArgsExpanded.begin() + end);
this->Makefile->AddDefinition(variableName, cmJoin(sublist, ";").c_str());
this->Makefile->AddDefinition(variableName, cmJoin(sublist, ";"));
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::string value = cmJoin(cmMakeRange(argsBegin, argsEnd), ";");
this->Makefile->AddDefinition(listName, value.c_str());
this->Makefile->AddDefinition(listName, value);
return true;
}
@ -1500,6 +1498,6 @@ bool cmListCommand::FilterRegex(std::vector<std::string> const& args,
std::remove_if(argsBegin, argsEnd, MatchesRegex(regex, includeMatches));
std::string value = cmJoin(cmMakeRange(argsBegin, newArgsEnd), ";");
this->Makefile->AddDefinition(listName, value.c_str());
this->Makefile->AddDefinition(listName, value);
return true;
}

2
Source/cmLoadCacheCommand.cxx
View File

@ -153,7 +153,7 @@ void cmLoadCacheCommand::CheckLine(const char* line)
// prefix.
var = this->Prefix + var;
if (!value.empty()) {
this->Makefile->AddDefinition(var, value.c_str());
this->Makefile->AddDefinition(var, value);
} else {
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.
this->Makefile->AddDefinition(reportVar, fullPath.c_str());
this->Makefile->AddDefinition(reportVar, fullPath);
// find the init function
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.
cmMakefile* mf = this->Makefile;
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_ICON_FILE");
cmLGInfoProp(mf, target, "MACOSX_BUNDLE_GUI_IDENTIFIER");
@ -3012,7 +3012,7 @@ void cmLocalGenerator::GenerateFrameworkInfoPList(
// back to the directory-level values set by the user.
cmMakefile* mf = this->Makefile;
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_IDENTIFIER");
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 noPolicyScope)
{
this->AddDefinition("CMAKE_PARENT_LIST_FILE",
this->GetDefinition("CMAKE_CURRENT_LIST_FILE"));
if (const char* def = this->GetDefinition("CMAKE_CURRENT_LIST_FILE")) {
this->AddDefinition("CMAKE_PARENT_LIST_FILE", def);
}
std::string filenametoread = cmSystemTools::CollapseFullPath(
filename, this->GetCurrentSourceDirectory());
@ -641,9 +642,9 @@ void cmMakefile::ReadListFile(cmListFile const& listFile,
this->GetSafeDefinition("CMAKE_PARENT_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",
cmSystemTools::GetFilenamePath(filenametoread).c_str());
cmSystemTools::GetFilenamePath(filenametoread));
this->MarkVariableAsUsed("CMAKE_PARENT_LIST_FILE");
this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_FILE");
@ -664,10 +665,10 @@ void cmMakefile::ReadListFile(cmListFile const& listFile,
}
this->CheckForUnusedVariables();
this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentParentFile.c_str());
this->AddDefinition("CMAKE_CURRENT_LIST_FILE", currentFile.c_str());
this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentParentFile);
this->AddDefinition("CMAKE_CURRENT_LIST_FILE", currentFile);
this->AddDefinition("CMAKE_CURRENT_LIST_DIR",
cmSystemTools::GetFilenamePath(currentFile).c_str());
cmSystemTools::GetFilenamePath(currentFile));
this->MarkVariableAsUsed("CMAKE_PARENT_LIST_FILE");
this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_FILE");
this->MarkVariableAsUsed("CMAKE_CURRENT_LIST_DIR");
@ -1535,7 +1536,7 @@ void cmMakefile::Configure()
cmSystemTools::MakeDirectory(filesDir);
assert(cmSystemTools::FileExists(currentStart, true));
this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentStart.c_str());
this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentStart);
cmListFile listFile;
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)) {
this->LogUnused("changing definition", name);
}
@ -1798,7 +1795,7 @@ void cmMakefile::AddDefinition(const std::string& name, const char* value)
cmVariableWatch* vv = this->GetVariableWatch();
if (vv) {
vv->VariableAccessed(name, cmVariableWatch::VARIABLE_MODIFIED_ACCESS,
value, this);
value.data(), this);
}
#endif
}
@ -3273,20 +3270,20 @@ std::string const& cmMakefile::GetHomeOutputDirectory() const
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)
{
std::ostringstream strStream;
strStream << args.size();
this->AddDefinition("CMAKE_ARGC", strStream.str().c_str());
this->AddDefinition("CMAKE_ARGC", strStream.str());
// this->MarkVariableAsUsed("CMAKE_ARGC");
for (unsigned int t = 0; t < args.size(); ++t) {
std::ostringstream tmpStream;
tmpStream << "CMAKE_ARGV" << t;
this->AddDefinition(tmpStream.str(), args[t].c_str());
this->AddDefinition(tmpStream.str(), args[t]);
// 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,
bool optional)
{
this->AddDefinition("CMAKE_CFG_INTDIR",
this->GetGlobalGenerator()->GetCMakeCFGIntDir());
if (const char* def = this->GetGlobalGenerator()->GetCMakeCFGIntDir()) {
this->AddDefinition("CMAKE_CFG_INTDIR", def);
}
// If RC is explicitly listed we need to do it after other languages.
// On some platforms we enable RC implicitly while enabling others.
// 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);
if (!m.empty()) {
std::string const& var = matchVariables[i];
this->AddDefinition(var, m.c_str());
this->AddDefinition(var, m);
this->MarkVariableAsUsed(var);
highest = static_cast<char>('0' + i);
}

6
Source/cmMakefile.h
View File

@ -17,6 +17,8 @@
#include <unordered_map>
#include <vector>
#include "cm_string_view.hxx"
#include "cmAlgorithms.h"
#include "cmFunctionBlocker.h"
#include "cmListFileCache.h"
@ -263,11 +265,11 @@ public:
* Add a variable definition to the build. This variable
* 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.
*/
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.
void AddCacheDefinition(const std::string& name, const char* value,
const char* doc, cmStateEnums::CacheEntryType type,

11
Source/cmParseArgumentsCommand.cxx
View File

@ -75,7 +75,7 @@ static void PassParsedArguments(
for (auto const& iter : singleValArgs) {
if (!iter.second.empty()) {
makefile.AddDefinition(prefix + iter.first, iter.second.c_str());
makefile.AddDefinition(prefix + iter.first, iter.second);
} else {
makefile.RemoveDefinition(prefix + iter.first);
}
@ -84,7 +84,7 @@ static void PassParsedArguments(
for (auto const& iter : multiValArgs) {
if (!iter.second.empty()) {
makefile.AddDefinition(prefix + iter.first,
JoinList(iter.second, parseFromArgV).c_str());
JoinList(iter.second, parseFromArgV));
} else {
makefile.RemoveDefinition(prefix + iter.first);
}
@ -92,15 +92,14 @@ static void PassParsedArguments(
if (!unparsed.empty()) {
makefile.AddDefinition(prefix + "UNPARSED_ARGUMENTS",
JoinList(unparsed, parseFromArgV).c_str());
JoinList(unparsed, parseFromArgV));
} else {
makefile.RemoveDefinition(prefix + "UNPARSED_ARGUMENTS");
}
if (!keywordsMissingValues.empty()) {
makefile.AddDefinition(
prefix + "KEYWORDS_MISSING_VALUES",
cmJoin(cmMakeRange(keywordsMissingValues), ";").c_str());
makefile.AddDefinition(prefix + "KEYWORDS_MISSING_VALUES",
cmJoin(cmMakeRange(keywordsMissingValues), ";"));
} else {
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(),
"Value Computed by CMake", cmStateEnums::STATIC);
this->Makefile->AddDefinition(
"PROJECT_BINARY_DIR", this->Makefile->GetCurrentBinaryDirectory().c_str());
this->Makefile->AddDefinition(
"PROJECT_SOURCE_DIR", this->Makefile->GetCurrentSourceDirectory().c_str());
this->Makefile->AddDefinition("PROJECT_BINARY_DIR",
this->Makefile->GetCurrentBinaryDirectory());
this->Makefile->AddDefinition("PROJECT_SOURCE_DIR",
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
// 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.
if (!this->Makefile->GetDefinition("CMAKE_PROJECT_NAME") ||
(this->Makefile->IsRootMakefile())) {
this->Makefile->AddDefinition("CMAKE_PROJECT_NAME", projectName.c_str());
this->Makefile->AddDefinition("CMAKE_PROJECT_NAME", projectName);
this->Makefile->AddCacheDefinition(
"CMAKE_PROJECT_NAME", projectName.c_str(), "Value Computed by CMake",
cmStateEnums::STATIC);
@ -258,24 +258,24 @@ bool cmProjectCommand::InitialPass(std::vector<std::string> const& args,
std::string vv;
vv = projectName + "_VERSION";
this->Makefile->AddDefinition("PROJECT_VERSION", version_string.c_str());
this->Makefile->AddDefinition(vv, version_string.c_str());
this->Makefile->AddDefinition("PROJECT_VERSION", version_string);
this->Makefile->AddDefinition(vv, version_string);
vv = projectName + "_VERSION_MAJOR";
this->Makefile->AddDefinition("PROJECT_VERSION_MAJOR",
version_components[0].c_str());
this->Makefile->AddDefinition(vv, version_components[0].c_str());
version_components[0]);
this->Makefile->AddDefinition(vv, version_components[0]);
vv = projectName + "_VERSION_MINOR";
this->Makefile->AddDefinition("PROJECT_VERSION_MINOR",
version_components[1].c_str());
this->Makefile->AddDefinition(vv, version_components[1].c_str());
version_components[1]);
this->Makefile->AddDefinition(vv, version_components[1]);
vv = projectName + "_VERSION_PATCH";
this->Makefile->AddDefinition("PROJECT_VERSION_PATCH",
version_components[2].c_str());
this->Makefile->AddDefinition(vv, version_components[2].c_str());
version_components[2]);
this->Makefile->AddDefinition(vv, version_components[2]);
vv = projectName + "_VERSION_TWEAK";
this->Makefile->AddDefinition("PROJECT_VERSION_TWEAK",
version_components[3].c_str());
this->Makefile->AddDefinition(vv, version_components[3].c_str());
version_components[3]);
this->Makefile->AddDefinition(vv, version_components[3]);
// Also, try set top level variables
TopLevelCMakeVarCondSet("CMAKE_PROJECT_VERSION", version_string.c_str());
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(projectName + "_DESCRIPTION",
description.c_str());
this->Makefile->AddDefinition("PROJECT_DESCRIPTION", description);
this->Makefile->AddDefinition(projectName + "_DESCRIPTION", description);
TopLevelCMakeVarCondSet("CMAKE_PROJECT_DESCRIPTION", description.c_str());
this->Makefile->AddDefinition("PROJECT_HOMEPAGE_URL", homepage.c_str());
this->Makefile->AddDefinition(projectName + "_HOMEPAGE_URL",
homepage.c_str());
this->Makefile->AddDefinition("PROJECT_HOMEPAGE_URL", homepage);
this->Makefile->AddDefinition(projectName + "_HOMEPAGE_URL", homepage);
TopLevelCMakeVarCondSet("CMAKE_PROJECT_HOMEPAGE_URL", homepage.c_str());
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.
this->Makefile->AddDefinition(sourceList, sourceListValue.c_str());
this->Makefile->AddDefinition(sourceList, sourceListValue);
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.
this->Makefile->AddDefinition(sourceList, sourceListValue.c_str());
this->Makefile->AddDefinition(headerList, headerListValue.c_str());
this->Makefile->AddDefinition(sourceList, sourceListValue);
this->Makefile->AddDefinition(headerList, headerListValue);
return true;
}

2
Source/cmRemoveCommand.cxx
View File

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

4
Source/cmSeparateArgumentsCommand.cxx
View File

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

2
Source/cmSetCommand.cxx
View File

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