mirrors/cmake
2
0 Fork 0
mirror of https://gitlab.kitware.com/cmake/cmake.git synced 2026-10-01 04:03:24 +03:00
Code Activity

cmMakefile::GetDefinition: return cmProp

Browse Source
This commit is contained in:
Vitaly Stakhovsky committed 2020-09-02 07:27:32 -04:00
1 parent 99b21e58e0
commit 11425041f0
83 files changed
+744 -701
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Source/CPack/cmCPackGenerator.cxx
+17 -14
View File
@@ -20,6 +20,7 @@
#include "cmGeneratedFileStream.h"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmState.h"
#include "cmStateSnapshot.h"
#include "cmStringAlgorithms.h"
@@ -905,8 +906,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 (const char* def = mf.GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES")) {
mf.AddDefinition("CPACK_ABSOLUTE_DESTINATION_FILES", def);
if (cmProp def = mf.GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES")) {
mf.AddDefinition("CPACK_ABSOLUTE_DESTINATION_FILES", *def);
}
// Now rebuild the list of files after installation
@@ -939,11 +940,11 @@ int cmCPackGenerator::InstallCMakeProject(
}
}
if (auto d = mf.GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES")) {
if (cmProp d = mf.GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES")) {
if (!absoluteDestFiles.empty()) {
absoluteDestFiles += ";";
}
absoluteDestFiles += d;
absoluteDestFiles += *d;
cmCPackLogger(cmCPackLog::LOG_DEBUG,
"Got some ABSOLUTE DESTINATION FILES: " << absoluteDestFiles
<< std::endl);
@@ -954,12 +955,13 @@ int cmCPackGenerator::InstallCMakeProject(
GetComponentInstallDirNameSuffix(component);
if (nullptr != this->GetOption(absoluteDestFileComponent)) {
std::string absoluteDestFilesListComponent =
cmStrCat(this->GetOption(absoluteDestFileComponent), ';', d);
cmStrCat(this->GetOption(absoluteDestFileComponent), ';', *d);
this->SetOption(absoluteDestFileComponent,
absoluteDestFilesListComponent.c_str());
} else {
this->SetOption(absoluteDestFileComponent,
mf.GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES"));
this->SetOption(
absoluteDestFileComponent,
cmToCStr(mf.GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES")));
}
}
}
@@ -982,7 +984,7 @@ bool cmCPackGenerator::ReadListFile(const char* moduleName)
void cmCPackGenerator::SetOptionIfNotSet(const std::string& op,
const char* value)
{
const char* def = this->MakefileMap->GetDefinition(op);
cmProp def = this->MakefileMap->GetDefinition(op);
if (cmNonempty(def)) {
return;
}
@@ -1214,30 +1216,31 @@ bool cmCPackGenerator::IsOn(const std::string& name) const
bool cmCPackGenerator::IsSetToOff(const std::string& op) const
{
const char* ret = this->MakefileMap->GetDefinition(op);
cmProp ret = this->MakefileMap->GetDefinition(op);
if (cmNonempty(ret)) {
return cmIsOff(ret);
return cmIsOff(*ret);
}
return false;
}
bool cmCPackGenerator::IsSetToEmpty(const std::string& op) const
{
const char* ret = this->MakefileMap->GetDefinition(op);
cmProp ret = this->MakefileMap->GetDefinition(op);
if (ret) {
return !*ret;
return ret->empty();
}
return false;
}
const char* cmCPackGenerator::GetOption(const std::string& op) const
{
const char* ret = this->MakefileMap->GetDefinition(op);
cmProp ret = this->MakefileMap->GetDefinition(op);
if (!ret) {
cmCPackLogger(cmCPackLog::LOG_DEBUG,
"Warning, GetOption return NULL for: " << op << std::endl);
return nullptr;
}
return ret;
return ret->c_str();
}
std::vector<std::string> cmCPackGenerator::GetOptions() const
Source/CPack/cpack.cxx
+16 -15
View File
@@ -12,6 +12,7 @@
#include "cmDocumentationFormatter.h"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmState.h"
#include "cmStateSnapshot.h"
#include "cmStringAlgorithms.h"
@@ -324,21 +325,22 @@ int main(int argc, char const* const* argv)
}
// Force CPACK_PACKAGE_DIRECTORY as absolute path
cpackProjectDirectory = globalMF.GetDefinition("CPACK_PACKAGE_DIRECTORY");
cpackProjectDirectory =
globalMF.GetSafeDefinition("CPACK_PACKAGE_DIRECTORY");
cpackProjectDirectory =
cmSystemTools::CollapseFullPath(cpackProjectDirectory);
globalMF.AddDefinition("CPACK_PACKAGE_DIRECTORY", cpackProjectDirectory);
const char* cpackModulesPath = globalMF.GetDefinition("CPACK_MODULE_PATH");
cmProp cpackModulesPath = globalMF.GetDefinition("CPACK_MODULE_PATH");
if (cpackModulesPath) {
globalMF.AddDefinition("CMAKE_MODULE_PATH", cpackModulesPath);
globalMF.AddDefinition("CMAKE_MODULE_PATH", *cpackModulesPath);
}
const char* genList = globalMF.GetDefinition("CPACK_GENERATOR");
cmProp genList = globalMF.GetDefinition("CPACK_GENERATOR");
if (!genList) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"CPack generator not specified" << std::endl);
} else {
std::vector<std::string> generatorsVector = cmExpandedList(genList);
std::vector<std::string> generatorsVector = cmExpandedList(*genList);
for (std::string const& gen : generatorsVector) {
cmMakefile::ScopePushPop raii(&globalMF);
cmMakefile* mf = &globalMF;
@@ -411,32 +413,31 @@ int main(int argc, char const* const* argv)
parsed = 0;
}
if (parsed) {
const char* projName = mf->GetDefinition("CPACK_PACKAGE_NAME");
cmProp projName = mf->GetDefinition("CPACK_PACKAGE_NAME");
cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
"Use generator: " << cpackGenerator->GetNameOfClass()
<< std::endl);
cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
"For project: " << projName << std::endl);
"For project: " << *projName << std::endl);
const char* projVersion =
mf->GetDefinition("CPACK_PACKAGE_VERSION");
cmProp projVersion = mf->GetDefinition("CPACK_PACKAGE_VERSION");
if (!projVersion) {
const char* projVersionMajor =
cmProp projVersionMajor =
mf->GetDefinition("CPACK_PACKAGE_VERSION_MAJOR");
const char* projVersionMinor =
cmProp projVersionMinor =
mf->GetDefinition("CPACK_PACKAGE_VERSION_MINOR");
const char* projVersionPatch =
cmProp projVersionPatch =
mf->GetDefinition("CPACK_PACKAGE_VERSION_PATCH");
std::ostringstream ostr;
ostr << projVersionMajor << "." << projVersionMinor << "."
<< projVersionPatch;
ostr << *projVersionMajor << "." << *projVersionMinor << "."
<< *projVersionPatch;
mf->AddDefinition("CPACK_PACKAGE_VERSION", ostr.str());
}
int res = cpackGenerator->DoPackage();
if (!res) {
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
"Error when generating package: " << projName
"Error when generating package: " << *projName
<< std::endl);
return 1;
}
Source/CTest/cmCTestBuildCommand.cxx
+28 -25
View File
@@ -2,7 +2,6 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmCTestBuildCommand.h"
#include <cstring>
#include <sstream>
#include <cmext/string_view>
@@ -39,12 +38,13 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
this->Handler = handler;
cmProp ctestBuildCommand = this->Makefile->GetDef("CTEST_BUILD_COMMAND");
cmProp ctestBuildCommand =
this->Makefile->GetDefinition("CTEST_BUILD_COMMAND");
if (cmNonempty(ctestBuildCommand)) {
this->CTest->SetCTestConfiguration("MakeCommand", *ctestBuildCommand,
this->Quiet);
} else {
const char* cmakeGeneratorName =
cmProp cmakeGeneratorName =
this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
// Build configuration is determined by: CONFIGURATION argument,
@@ -52,49 +52,51 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
// CTEST_CONFIGURATION_TYPE script variable, or ctest -C command
// line argument... in that order.
//
const char* ctestBuildConfiguration =
cmProp ctestBuildConfiguration =
this->Makefile->GetDefinition("CTEST_BUILD_CONFIGURATION");
const char* cmakeBuildConfiguration = !this->Configuration.empty()
? this->Configuration.c_str()
: (cmNonempty(ctestBuildConfiguration)
? ctestBuildConfiguration
: this->CTest->GetConfigType().c_str());
const std::string* cmakeBuildConfiguration = !this->Configuration.empty()
? &this->Configuration
: (cmNonempty(ctestBuildConfiguration) ? ctestBuildConfiguration
: &this->CTest->GetConfigType());
const char* cmakeBuildAdditionalFlags = !this->Flags.empty()
? this->Flags.c_str()
const std::string* cmakeBuildAdditionalFlags = !this->Flags.empty()
? &this->Flags
: this->Makefile->GetDefinition("CTEST_BUILD_FLAGS");
const char* cmakeBuildTarget = !this->Target.empty()
? this->Target.c_str()
const std::string* cmakeBuildTarget = !this->Target.empty()
? &this->Target
: this->Makefile->GetDefinition("CTEST_BUILD_TARGET");
if (cmNonempty(cmakeGeneratorName)) {
if (!cmakeBuildConfiguration) {
cmakeBuildConfiguration = "Release";
static const std::string sRelease = "Release";
cmakeBuildConfiguration = &sRelease;
}
if (this->GlobalGenerator) {
if (this->GlobalGenerator->GetName() != cmakeGeneratorName) {
if (this->GlobalGenerator->GetName() != *cmakeGeneratorName) {
this->GlobalGenerator.reset();
}
}
if (!this->GlobalGenerator) {
this->GlobalGenerator =
this->Makefile->GetCMakeInstance()->CreateGlobalGenerator(
cmakeGeneratorName);
*cmakeGeneratorName);
if (!this->GlobalGenerator) {
std::string e = cmStrCat("could not create generator named \"",
cmakeGeneratorName, '"');
*cmakeGeneratorName, '"');
this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e);
cmSystemTools::SetFatalErrorOccured();
return nullptr;
}
}
if (strlen(cmakeBuildConfiguration) == 0) {
const char* config = nullptr;
if (cmakeBuildConfiguration->empty()) {
const std::string* config = nullptr;
#ifdef CMAKE_INTDIR
config = CMAKE_INTDIR;
static const std::string sIntDir = CMAKE_INTDIR;
config = &sIntDir;
#endif
if (!config) {
config = "Debug";
static const std::string sDebug = "Debug";
config = &sDebug;
}
cmakeBuildConfiguration = config;
}
@@ -102,8 +104,8 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
std::string dir = this->CTest->GetCTestConfiguration("BuildDirectory");
std::string buildCommand =
this->GlobalGenerator->GenerateCMakeBuildCommand(
cmakeBuildTarget ? cmakeBuildTarget : "", cmakeBuildConfiguration,
cmakeBuildAdditionalFlags ? cmakeBuildAdditionalFlags : "",
cmakeBuildTarget ? *cmakeBuildTarget : "", *cmakeBuildConfiguration,
cmakeBuildAdditionalFlags ? *cmakeBuildAdditionalFlags : "",
this->Makefile->IgnoreErrorsCMP0061());
cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
"SetMakeCommand:" << buildCommand << "\n",
@@ -123,13 +125,14 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
}
}
if (cmProp useLaunchers = this->Makefile->GetDef("CTEST_USE_LAUNCHERS")) {
if (cmProp useLaunchers =
this->Makefile->GetDefinition("CTEST_USE_LAUNCHERS")) {
this->CTest->SetCTestConfiguration("UseLaunchers", *useLaunchers,
this->Quiet);
}
if (cmProp labelsForSubprojects =
this->Makefile->GetDef("CTEST_LABELS_FOR_SUBPROJECTS")) {
this->Makefile->GetDefinition("CTEST_LABELS_FOR_SUBPROJECTS")) {
this->CTest->SetCTestConfiguration("LabelsForSubprojects",
*labelsForSubprojects, this->Quiet);
}
Source/CTest/cmCTestBuildHandler.cxx
+6 -4
View File
@@ -19,6 +19,7 @@
#include "cmGeneratedFileStream.h"
#include "cmMakefile.h"
#include "cmProcessOutput.h"
#include "cmProperty.h"
#include "cmStringAlgorithms.h"
#include "cmStringReplaceHelper.h"
#include "cmSystemTools.h"
@@ -248,13 +249,14 @@ void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile* mf)
}
// Record the user-specified custom warning rules.
if (const char* customWarningMatchers =
if (cmProp customWarningMatchers =
mf->GetDefinition("CTEST_CUSTOM_WARNING_MATCH")) {
cmExpandList(customWarningMatchers, this->ReallyCustomWarningMatches);
cmExpandList(*customWarningMatchers, this->ReallyCustomWarningMatches);
}
if (const char* customWarningExceptions =
if (cmProp customWarningExceptions =
mf->GetDefinition("CTEST_CUSTOM_WARNING_EXCEPTION")) {
cmExpandList(customWarningExceptions, this->ReallyCustomWarningExceptions);
cmExpandList(*customWarningExceptions,
this->ReallyCustomWarningExceptions);
}
}
Source/CTest/cmCTestConfigureCommand.cxx
+9 -9
View File
@@ -40,13 +40,13 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
}
cmProp ctestConfigureCommand =
this->Makefile->GetDef("CTEST_CONFIGURE_COMMAND");
this->Makefile->GetDefinition("CTEST_CONFIGURE_COMMAND");
if (cmNonempty(ctestConfigureCommand)) {
this->CTest->SetCTestConfiguration("ConfigureCommand",
*ctestConfigureCommand, this->Quiet);
} else {
const char* cmakeGeneratorName =
cmProp cmakeGeneratorName =
this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR");
if (cmNonempty(cmakeGeneratorName)) {
const std::string& source_dir =
@@ -71,7 +71,7 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
bool cmakeBuildTypeInOptions = false;
auto gg = this->Makefile->GetCMakeInstance()->CreateGlobalGenerator(
cmakeGeneratorName);
*cmakeGeneratorName);
if (gg) {
multiConfig = gg->IsMultiConfig();
gg.reset();
@@ -103,22 +103,22 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
}
cmakeConfigureCommand += " \"-G";
cmakeConfigureCommand += cmakeGeneratorName;
cmakeConfigureCommand += *cmakeGeneratorName;
cmakeConfigureCommand += "\"";
const char* cmakeGeneratorPlatform =
cmProp cmakeGeneratorPlatform =
this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR_PLATFORM");
if (cmNonempty(cmakeGeneratorPlatform)) {
cmakeConfigureCommand += " \"-A";
cmakeConfigureCommand += cmakeGeneratorPlatform;
cmakeConfigureCommand += *cmakeGeneratorPlatform;
cmakeConfigureCommand += "\"";
}
const char* cmakeGeneratorToolset =
cmProp cmakeGeneratorToolset =
this->Makefile->GetDefinition("CTEST_CMAKE_GENERATOR_TOOLSET");
if (cmNonempty(cmakeGeneratorToolset)) {
cmakeConfigureCommand += " \"-T";
cmakeConfigureCommand += cmakeGeneratorToolset;
cmakeConfigureCommand += *cmakeGeneratorToolset;
cmakeConfigureCommand += "\"";
}
@@ -138,7 +138,7 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
}
if (cmProp labelsForSubprojects =
this->Makefile->GetDef("CTEST_LABELS_FOR_SUBPROJECTS")) {
this->Makefile->GetDefinition("CTEST_LABELS_FOR_SUBPROJECTS")) {
this->CTest->SetCTestConfiguration("LabelsForSubprojects",
*labelsForSubprojects, this->Quiet);
}
Source/CTest/cmCTestHandlerCommand.cxx
+3 -2
View File
@@ -126,7 +126,8 @@ bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args,
// CTEST_CONFIGURATION_TYPE script variable if it is defined.
// The current script value trumps the -C argument on the command
// line.
cmProp ctestConfigType = this->Makefile->GetDef("CTEST_CONFIGURATION_TYPE");
cmProp ctestConfigType =
this->Makefile->GetDefinition("CTEST_CONFIGURATION_TYPE");
if (ctestConfigType) {
this->CTest->SetConfigType(*ctestConfigType);
}
@@ -160,7 +161,7 @@ bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args,
this->Quiet);
}
if (cmProp changeId = this->Makefile->GetDef("CTEST_CHANGE_ID")) {
if (cmProp changeId = this->Makefile->GetDefinition("CTEST_CHANGE_ID")) {
this->CTest->SetCTestConfiguration("ChangeId", *changeId, this->Quiet);
}
Source/CTest/cmCTestScriptHandler.cxx
+9 -8
View File
@@ -35,6 +35,7 @@
#include "cmGeneratedFileStream.h"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmState.h"
#include "cmStateDirectory.h"
#include "cmStateSnapshot.h"
@@ -372,8 +373,8 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg)
int cmCTestScriptHandler::ExtractVariables()
{
// Temporary variables
const char* minInterval;
const char* contDuration;
cmProp minInterval;
cmProp contDuration;
this->SourceDir =
this->Makefile->GetSafeDefinition("CTEST_SOURCE_DIRECTORY");
@@ -412,7 +413,7 @@ int cmCTestScriptHandler::ExtractVariables()
int i;
for (i = 1; i < 10; ++i) {
sprintf(updateVar, "CTEST_EXTRA_UPDATES_%i", i);
const char* updateVal = this->Makefile->GetDefinition(updateVar);
cmProp updateVal = this->Makefile->GetDefinition(updateVar);
if (updateVal) {
if (this->UpdateCmd.empty()) {
cmSystemTools::Error(
@@ -420,7 +421,7 @@ int cmCTestScriptHandler::ExtractVariables()
" specified without specifying CTEST_CVS_COMMAND.");
return 12;
}
this->ExtraUpdates.emplace_back(updateVal);
this->ExtraUpdates.emplace_back(*updateVal);
}
}
@@ -455,10 +456,10 @@ int cmCTestScriptHandler::ExtractVariables()
// the script may override the minimum continuous interval
if (minInterval) {
this->MinimumInterval = 60 * atof(minInterval);
this->MinimumInterval = 60 * atof(minInterval->c_str());
}
if (contDuration) {
this->ContinuousDuration = 60.0 * atof(contDuration);
this->ContinuousDuration = 60.0 * atof(contDuration->c_str());
}
this->UpdateElapsedTime();
@@ -932,13 +933,13 @@ cmDuration cmCTestScriptHandler::GetRemainingTimeAllowed()
return cmCTest::MaxDuration();
}
const char* timelimitS = this->Makefile->GetDefinition("CTEST_TIME_LIMIT");
cmProp timelimitS = this->Makefile->GetDefinition("CTEST_TIME_LIMIT");
if (!timelimitS) {
return cmCTest::MaxDuration();
}
auto timelimit = cmDuration(atof(timelimitS));
auto timelimit = cmDuration(atof(timelimitS->c_str()));
auto duration = std::chrono::duration_cast<cmDuration>(
std::chrono::steady_clock::now() - this->ScriptStartTime);
Source/CTest/cmCTestStartCommand.cxx
+15 -14
View File
@@ -9,6 +9,7 @@
#include "cmCTestVC.h"
#include "cmGeneratedFileStream.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmSystemTools.h"
class cmExecutionStatus;
@@ -29,8 +30,8 @@ bool cmCTestStartCommand::InitialPass(std::vector<std::string> const& args,
size_t cnt = 0;
const char* smodel = nullptr;
const char* src_dir = nullptr;
const char* bld_dir = nullptr;
const std::string* src_dir = nullptr;
const std::string* bld_dir = nullptr;
while (cnt < args.size()) {
if (args[cnt] == "GROUP" || args[cnt] == "TRACK") {
@@ -54,10 +55,10 @@ bool cmCTestStartCommand::InitialPass(std::vector<std::string> const& args,
smodel = args[cnt].c_str();
cnt++;
} else if (!src_dir) {
src_dir = args[cnt].c_str();
src_dir = &args[cnt];
cnt++;
} else if (!bld_dir) {
bld_dir = args[cnt].c_str();
bld_dir = &args[cnt];
cnt++;
} else {
this->SetError("Too many arguments");
@@ -87,13 +88,13 @@ bool cmCTestStartCommand::InitialPass(std::vector<std::string> const& args,
return false;
}
cmSystemTools::AddKeepPath(src_dir);
cmSystemTools::AddKeepPath(bld_dir);
cmSystemTools::AddKeepPath(*src_dir);
cmSystemTools::AddKeepPath(*bld_dir);
this->CTest->EmptyCTestConfiguration();
std::string sourceDir = cmSystemTools::CollapseFullPath(src_dir);
std::string binaryDir = cmSystemTools::CollapseFullPath(bld_dir);
std::string sourceDir = cmSystemTools::CollapseFullPath(*src_dir);
std::string binaryDir = cmSystemTools::CollapseFullPath(*bld_dir);
this->CTest->SetCTestConfiguration("SourceDirectory", sourceDir,
this->Quiet);
this->CTest->SetCTestConfiguration("BuildDirectory", binaryDir, this->Quiet);
@@ -102,16 +103,16 @@ bool cmCTestStartCommand::InitialPass(std::vector<std::string> const& args,
cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
"Run dashboard with model "
<< smodel << std::endl
<< " Source directory: " << src_dir << std::endl
<< " Build directory: " << bld_dir << std::endl,
<< " Source directory: " << *src_dir << std::endl
<< " Build directory: " << *bld_dir << std::endl,
this->Quiet);
} else {
cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
"Run dashboard with "
"to-be-determined model"
<< std::endl
<< " Source directory: " << src_dir << std::endl
<< " Build directory: " << bld_dir << std::endl,
<< " Source directory: " << *src_dir << std::endl
<< " Build directory: " << *bld_dir << std::endl,
this->Quiet);
}
const char* group = this->CTest->GetSpecificGroup();
@@ -161,7 +162,7 @@ bool cmCTestStartCommand::InitialCheckout(std::ostream& ofs,
std::string const& sourceDir)
{
// Use the user-provided command to create the source tree.
const char* initialCheckoutCommand =
cmProp initialCheckoutCommand =
this->Makefile->GetDefinition("CTEST_CHECKOUT_COMMAND");
if (!initialCheckoutCommand) {
initialCheckoutCommand =
@@ -171,7 +172,7 @@ bool cmCTestStartCommand::InitialCheckout(std::ostream& ofs,
// Use a generic VC object to run and log the command.
cmCTestVC vc(this->CTest, ofs);
vc.SetSourceDirectory(sourceDir);
if (!vc.InitialCheckout(initialCheckoutCommand)) {
if (!vc.InitialCheckout(*initialCheckoutCommand)) {
return false;
}
}
Source/CTest/cmCTestSubmitCommand.cxx
+6 -5
View File
@@ -16,6 +16,7 @@
#include "cmCommand.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmProperty.h"
#include "cmRange.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
@@ -37,7 +38,7 @@ cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
{
const std::string* submitURL = !this->SubmitURL.empty()
? &this->SubmitURL
: this->Makefile->GetDef("CTEST_SUBMIT_URL");
: this->Makefile->GetDefinition("CTEST_SUBMIT_URL");
if (submitURL) {
this->CTest->SetCTestConfiguration("SubmitURL", *submitURL, this->Quiet);
@@ -58,17 +59,17 @@ cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
this->CTest->SetCTestConfigurationFromCMakeVariable(
this->Makefile, "CurlOptions", "CTEST_CURL_OPTIONS", this->Quiet);
const char* notesFilesVariable =
cmProp notesFilesVariable =
this->Makefile->GetDefinition("CTEST_NOTES_FILES");
if (notesFilesVariable) {
std::vector<std::string> notesFiles = cmExpandedList(notesFilesVariable);
std::vector<std::string> notesFiles = cmExpandedList(*notesFilesVariable);
this->CTest->GenerateNotesFile(notesFiles);
}
const char* extraFilesVariable =
cmProp extraFilesVariable =
this->Makefile->GetDefinition("CTEST_EXTRA_SUBMIT_FILES");
if (extraFilesVariable) {
std::vector<std::string> extraFiles = cmExpandedList(extraFilesVariable);
std::vector<std::string> extraFiles = cmExpandedList(*extraFilesVariable);
if (!this->CTest->SubmitExtraFiles(extraFiles)) {
this->SetError("problem submitting extra files.");
return nullptr;
Source/CTest/cmCTestTestCommand.cxx
+8 -9
View File
@@ -40,12 +40,11 @@ void cmCTestTestCommand::BindArguments()
cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
{
const char* ctestTimeout =
this->Makefile->GetDefinition("CTEST_TEST_TIMEOUT");
cmProp ctestTimeout = this->Makefile->GetDefinition("CTEST_TEST_TIMEOUT");
cmDuration timeout;
if (ctestTimeout) {
timeout = cmDuration(atof(ctestTimeout));
timeout = cmDuration(atof(ctestTimeout->c_str()));
} else {
timeout = this->CTest->GetTimeOut();
if (timeout <= cmDuration::zero()) {
@@ -55,10 +54,10 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
}
this->CTest->SetTimeOut(timeout);
const char* resourceSpecFile =
cmProp resourceSpecFile =
this->Makefile->GetDefinition("CTEST_RESOURCE_SPEC_FILE");
if (this->ResourceSpecFile.empty() && resourceSpecFile) {
this->ResourceSpecFile = resourceSpecFile;
this->ResourceSpecFile = *resourceSpecFile;
}
cmCTestGenericHandler* handler = this->InitializeActualHandler();
@@ -115,7 +114,7 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
// or CTEST_TEST_LOAD script variable, or ctest --test-load
// command line argument... in that order.
unsigned long testLoad;
const char* ctestTestLoad = this->Makefile->GetDefinition("CTEST_TEST_LOAD");
cmProp ctestTestLoad = this->Makefile->GetDefinition("CTEST_TEST_LOAD");
if (!this->TestLoad.empty()) {
if (!cmStrToULong(this->TestLoad, &testLoad)) {
testLoad = 0;
@@ -124,10 +123,10 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
<< std::endl);
}
} else if (cmNonempty(ctestTestLoad)) {
if (!cmStrToULong(ctestTestLoad, &testLoad)) {
if (!cmStrToULong(*ctestTestLoad, &testLoad)) {
testLoad = 0;
cmCTestLog(this->CTest, WARNING,
"Invalid value for 'CTEST_TEST_LOAD' : " << ctestTestLoad
"Invalid value for 'CTEST_TEST_LOAD' : " << *ctestTestLoad
<< std::endl);
}
} else {
@@ -136,7 +135,7 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
handler->SetTestLoad(testLoad);
if (cmProp labelsForSubprojects =
this->Makefile->GetDef("CTEST_LABELS_FOR_SUBPROJECTS")) {
this->Makefile->GetDefinition("CTEST_LABELS_FOR_SUBPROJECTS")) {
this->CTest->SetCTestConfiguration("LabelsForSubprojects",
*labelsForSubprojects, this->Quiet);
}
Source/CTest/cmCTestTestHandler.cxx
+3 -2
View File
@@ -37,6 +37,7 @@
#include "cmGeneratedFileStream.h"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmState.h"
#include "cmStateSnapshot.h"
#include "cmStringAlgorithms.h"
@@ -1764,9 +1765,9 @@ bool cmCTestTestHandler::GetListOfTests()
// SEND_ERROR or FATAL_ERROR in CTestTestfile or TEST_INCLUDE_FILES
return false;
}
const char* specFile = mf.GetDefinition("CTEST_RESOURCE_SPEC_FILE");
cmProp specFile = mf.GetDefinition("CTEST_RESOURCE_SPEC_FILE");
if (this->ResourceSpecFile.empty() && specFile) {
this->ResourceSpecFile = specFile;
this->ResourceSpecFile = *specFile;
}
cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
"Done constructing a list of tests" << std::endl,
Source/CTest/cmCTestUpdateCommand.cxx
+2 -1
View File
@@ -5,6 +5,7 @@
#include "cmCTest.h"
#include "cmCTestUpdateHandler.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmSystemTools.h"
cmCTestGenericHandler* cmCTestUpdateCommand::InitializeHandler()
@@ -17,7 +18,7 @@ cmCTestGenericHandler* cmCTestUpdateCommand::InitializeHandler()
this->CTest->SetCTestConfiguration(
"SourceDirectory",
cmSystemTools::CollapseFullPath(
this->Makefile->GetDefinition("CTEST_SOURCE_DIRECTORY")),
cmToCStrSafe(this->Makefile->GetDefinition("CTEST_SOURCE_DIRECTORY"))),
this->Quiet);
}
std::string source_dir =
Source/cmAuxSourceDirectoryCommand.cxx
+1 -4
View File
@@ -36,10 +36,7 @@ bool cmAuxSourceDirectoryCommand(std::vector<std::string> const& args,
}
// was the list already populated
const char* def = mf.GetDefinition(args[1]);
if (def) {
sourceListValue = def;
}
sourceListValue = mf.GetSafeDefinition(args[1]);
std::vector<std::string> files;
Source/cmBuildCommand.cxx
+2 -1
View File
@@ -6,6 +6,7 @@
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmProperty.h"
#include "cmStateTypes.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
@@ -94,7 +95,7 @@ bool TwoArgsSignature(std::vector<std::string> const& args,
cmMakefile& mf = status.GetMakefile();
std::string const& define = args[0];
const char* cacheValue = mf.GetDefinition(define);
cmProp cacheValue = mf.GetDefinition(define);
std::string configType;
if (!cmSystemTools::GetEnv("CMAKE_CONFIG_TYPE", configType) ||
Source/cmBuildNameCommand.cxx
+4 -3
View File
@@ -8,6 +8,7 @@
#include "cmExecutionStatus.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmStateTypes.h"
#include "cmSystemTools.h"
@@ -19,12 +20,12 @@ bool cmBuildNameCommand(std::vector<std::string> const& args,
return false;
}
cmMakefile& mf = status.GetMakefile();
const char* cacheValue = mf.GetDefinition(args[0]);
cmProp cacheValue = mf.GetDefinition(args[0]);
if (cacheValue) {
// do we need to correct the value?
cmsys::RegularExpression reg("[()/]");
if (reg.find(cacheValue)) {
std::string cv = cacheValue;
std::string cv = *cacheValue;
if (reg.find(cv)) {
std::replace(cv.begin(), cv.end(), '/', '_');
std::replace(cv.begin(), cv.end(), '(', '_');
std::replace(cv.begin(), cv.end(), ')', '_');
Source/cmCPluginAPI.cxx
+1 -1
View File
@@ -140,7 +140,7 @@ const char* CCONV cmGetCurrentOutputDirectory(void* arg)
const char* CCONV cmGetDefinition(void* arg, const char* def)
{
cmMakefile* mf = static_cast<cmMakefile*>(arg);
return mf->GetDefinition(def);
return cmToCStr(mf->GetDefinition(def));
}
int CCONV cmIsOn(void* arg, const char* name)
Source/cmCTest.cxx
+5 -5
View File
@@ -2620,14 +2620,14 @@ int cmCTest::ReadCustomConfigurationFileTree(const std::string& dir,
void cmCTest::PopulateCustomVector(cmMakefile* mf, const std::string& def,
std::vector<std::string>& vec)
{
const char* dval = mf->GetDefinition(def);
cmProp dval = mf->GetDefinition(def);
if (!dval) {
return;
}
cmCTestLog(this, DEBUG, "PopulateCustomVector: " << def << std::endl);
vec.clear();
cmExpandList(dval, vec);
cmExpandList(*dval, vec);
for (std::string const& it : vec) {
cmCTestLog(this, DEBUG, " -- " << it << std::endl);
@@ -2637,11 +2637,11 @@ void cmCTest::PopulateCustomVector(cmMakefile* mf, const std::string& def,
void cmCTest::PopulateCustomInteger(cmMakefile* mf, const std::string& def,
int& val)
{
const char* dval = mf->GetDefinition(def);
cmProp dval = mf->GetDefinition(def);
if (!dval) {
return;
}
val = atoi(dval);
val = atoi(dval->c_str());
}
std::string cmCTest::GetShortPathToFile(const std::string& cfname)
@@ -2971,7 +2971,7 @@ bool cmCTest::SetCTestConfigurationFromCMakeVariable(
cmMakefile* mf, const char* dconfig, const std::string& cmake_var,
bool suppress)
{
cmProp ctvar = mf->GetDef(cmake_var);
cmProp ctvar = mf->GetDefinition(cmake_var);
if (!ctvar) {
return false;
}
Source/cmCommandArgumentParserHelper.cxx
+3 -3
View File
@@ -93,7 +93,7 @@ const char* cmCommandArgumentParserHelper::ExpandVariable(const char* var)
if (this->FileLine >= 0 && strcmp(var, "CMAKE_CURRENT_LIST_LINE") == 0) {
return this->AddString(std::to_string(this->FileLine));
}
const char* value = this->Makefile->GetDefinition(var);
cmProp value = this->Makefile->GetDefinition(var);
if (!value) {
this->Makefile->MaybeWarnUninitialized(var, this->FileName);
if (!this->RemoveEmpty) {
@@ -101,9 +101,9 @@ const char* cmCommandArgumentParserHelper::ExpandVariable(const char* var)
}
}
if (this->EscapeQuotes && value) {
return this->AddString(cmEscapeQuotes(value));
return this->AddString(cmEscapeQuotes(*value));
}
return this->AddString(value ? value : "");
return this->AddString(cmToCStrSafe(value));
}
const char* cmCommandArgumentParserHelper::ExpandVariableForAt(const char* var)
Source/cmCommonTargetGenerator.cxx
+4 -4
View File
@@ -55,7 +55,7 @@ void cmCommonTargetGenerator::AddModuleDefinitionFlag(
}
// TODO: Create a per-language flag variable.
const char* defFileFlag =
cmProp defFileFlag =
this->Makefile->GetDefinition("CMAKE_LINK_DEF_FILE_FLAG");
if (!defFileFlag) {
return;
@@ -64,7 +64,7 @@ void cmCommonTargetGenerator::AddModuleDefinitionFlag(
// Append the flag and value. Use ConvertToLinkReference to help
// vs6's "cl -link" pass it to the linker.
std::string flag =
cmStrCat(defFileFlag,
cmStrCat(*defFileFlag,
this->LocalCommonGenerator->ConvertToOutputFormat(
linkLineComputer->ConvertToLinkReference(mdi->DefFile),
cmOutputConverter::SHELL));
@@ -270,7 +270,7 @@ void cmCommonTargetGenerator::AppendOSXVerFlag(std::string& flags,
{
// Lookup the flag to specify the version.
std::string fvar = cmStrCat("CMAKE_", lang, "_OSX_", name, "_VERSION_FLAG");
const char* flag = this->Makefile->GetDefinition(fvar);
cmProp flag = this->Makefile->GetDefinition(fvar);
// Skip if no such flag.
if (!flag) {
@@ -288,7 +288,7 @@ void cmCommonTargetGenerator::AppendOSXVerFlag(std::string& flags,
if (major > 0 || minor > 0 || patch > 0) {
// Append the flag since a non-zero version is specified.
std::ostringstream vflag;
vflag << flag << major << "." << minor << "." << patch;
vflag << *flag << major << "." << minor << "." << patch;
this->LocalCommonGenerator->AppendFlags(flags, vflag.str());
}
}
Source/cmComputeLinkDepends.cxx
+6 -6
View File
@@ -5,7 +5,6 @@
#include <algorithm>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <iterator>
#include <sstream>
#include <utility>
@@ -18,6 +17,7 @@
#include "cmListFileCache.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmRange.h"
#include "cmStateTypes.h"
#include "cmStringAlgorithms.h"
@@ -315,9 +315,9 @@ int cmComputeLinkDepends::AddLinkEntry(cmLinkItem const& item)
} else {
// Look for an old-style <item>_LIB_DEPENDS variable.
std::string var = cmStrCat(entry.Item.Value, "_LIB_DEPENDS");
if (const char* val = this->Makefile->GetDefinition(var)) {
if (cmProp val = this->Makefile->GetDefinition(var)) {
// The item dependencies are known. Follow them.
BFSEntry qe = { index, val };
BFSEntry qe = { index, val->c_str() };
this->BFSQueue.push(qe);
} else if (!entry.IsFlag) {
// The item dependencies are not known. We need to infer them.
@@ -454,10 +454,10 @@ void cmComputeLinkDepends::AddVarLinkEntries(int depender_index,
// lower.
if (!haveLLT) {
std::string var = cmStrCat(d, "_LINK_TYPE");
if (const char* val = this->Makefile->GetDefinition(var)) {
if (strcmp(val, "debug") == 0) {
if (cmProp val = this->Makefile->GetDefinition(var)) {
if (*val == "debug") {
llt = DEBUG_LibraryType;
} else if (strcmp(val, "optimized") == 0) {
} else if (*val == "optimized") {
llt = OPTIMIZED_LibraryType;
}
}
Source/cmComputeLinkInformation.cxx
+32 -34
View File
@@ -4,7 +4,6 @@
#include <algorithm>
#include <cctype>
#include <cstring>
#include <sstream>
#include <utility>
@@ -284,27 +283,28 @@ cmComputeLinkInformation::cmComputeLinkInformation(
this->Target->GetType() == cmStateEnums::MODULE_LIBRARY) {
std::string loader_flag_var =
cmStrCat("CMAKE_SHARED_MODULE_LOADER_", this->LinkLanguage, "_FLAG");
this->LoaderFlag = this->Makefile->GetDefinition(loader_flag_var);
this->LoaderFlag =
cmToCStr(this->Makefile->GetDefinition(loader_flag_var));
}
// Get options needed to link libraries.
if (const char* flag = this->Makefile->GetDefinition(
if (cmProp flag = this->Makefile->GetDefinition(
"CMAKE_" + this->LinkLanguage + "_LINK_LIBRARY_FLAG")) {
this->LibLinkFlag = flag;
this->LibLinkFlag = *flag;
} else {
this->LibLinkFlag =
this->Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_FLAG");
}
if (const char* flag = this->Makefile->GetDefinition(
if (cmProp flag = this->Makefile->GetDefinition(
"CMAKE_" + this->LinkLanguage + "_LINK_LIBRARY_FILE_FLAG")) {
this->LibLinkFileFlag = flag;
this->LibLinkFileFlag = *flag;
} else {
this->LibLinkFileFlag =
this->Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_FILE_FLAG");
}
if (const char* suffix = this->Makefile->GetDefinition(
if (cmProp suffix = this->Makefile->GetDefinition(
"CMAKE_" + this->LinkLanguage + "_LINK_LIBRARY_SUFFIX")) {
this->LibLinkSuffix = suffix;
this->LibLinkSuffix = *suffix;
} else {
this->LibLinkSuffix =
this->Makefile->GetSafeDefinition("CMAKE_LINK_LIBRARY_SUFFIX");
@@ -593,9 +593,9 @@ void cmComputeLinkInformation::AddRuntimeLinkLibrary(std::string const& lang)
if (runtimeLibrary.empty()) {
return;
}
if (const char* runtimeLinkOptions = this->Makefile->GetDefinition(
if (cmProp runtimeLinkOptions = this->Makefile->GetDefinition(
"CMAKE_" + lang + "_RUNTIME_LIBRARY_LINK_OPTIONS_" + runtimeLibrary)) {
std::vector<std::string> libsVec = cmExpandedList(runtimeLinkOptions);
std::vector<std::string> libsVec = cmExpandedList(*runtimeLinkOptions);
for (std::string const& i : libsVec) {
if (!cm::contains(this->ImplicitLinkLibs, i)) {
this->AddItem(i, nullptr);
@@ -609,8 +609,8 @@ void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang)
// Add libraries for this language that are not implied by the
// linker language.
std::string libVar = cmStrCat("CMAKE_", lang, "_IMPLICIT_LINK_LIBRARIES");
if (const char* libs = this->Makefile->GetDefinition(libVar)) {
std::vector<std::string> libsVec = cmExpandedList(libs);
if (cmProp libs = this->Makefile->GetDefinition(libVar)) {
std::vector<std::string> libsVec = cmExpandedList(*libs);
for (std::string const& i : libsVec) {
if (!cm::contains(this->ImplicitLinkLibs, i)) {
this->AddItem(i, nullptr);
@@ -621,8 +621,8 @@ void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang)
// Add linker search paths for this language that are not
// implied by the linker language.
std::string dirVar = cmStrCat("CMAKE_", lang, "_IMPLICIT_LINK_DIRECTORIES");
if (const char* dirs = this->Makefile->GetDefinition(dirVar)) {
std::vector<std::string> dirsVec = cmExpandedList(dirs);
if (cmProp dirs = this->Makefile->GetDefinition(dirVar)) {
std::vector<std::string> dirsVec = cmExpandedList(*dirs);
this->OrderLinkerSearchPath->AddLanguageDirectories(dirsVec);
}
}
@@ -800,8 +800,8 @@ void cmComputeLinkInformation::ComputeLinkTypeInfo()
this->LinkTypeEnabled = false;
// Lookup link type selection flags.
const char* static_link_type_flag = nullptr;
const char* shared_link_type_flag = nullptr;
cmProp static_link_type_flag = nullptr;
cmProp shared_link_type_flag = nullptr;
const char* target_type_str = nullptr;
switch (this->Target->GetType()) {
case cmStateEnums::EXECUTABLE:
@@ -834,8 +834,8 @@ void cmComputeLinkInformation::ComputeLinkTypeInfo()
// known.
if (cmNonempty(static_link_type_flag) && cmNonempty(shared_link_type_flag)) {
this->LinkTypeEnabled = true;
this->StaticLinkTypeFlag = static_link_type_flag;
this->SharedLinkTypeFlag = shared_link_type_flag;
this->StaticLinkTypeFlag = *static_link_type_flag;
this->SharedLinkTypeFlag = *shared_link_type_flag;
}
// Lookup the starting link type from the target (linked statically?).
@@ -861,16 +861,15 @@ void cmComputeLinkInformation::ComputeItemParserInfo()
LinkShared);
this->AddLinkExtension(mf->GetSafeDefinition("CMAKE_LINK_LIBRARY_SUFFIX"),
LinkUnknown);
if (const char* linkSuffixes =
mf->GetDefinition("CMAKE_EXTRA_LINK_EXTENSIONS")) {
std::vector<std::string> linkSuffixVec = cmExpandedList(linkSuffixes);
if (cmProp linkSuffixes = mf->GetDefinition("CMAKE_EXTRA_LINK_EXTENSIONS")) {
std::vector<std::string> linkSuffixVec = cmExpandedList(*linkSuffixes);
for (std::string const& i : linkSuffixVec) {
this->AddLinkExtension(i, LinkUnknown);
}
}
if (const char* sharedSuffixes =
if (cmProp sharedSuffixes =
mf->GetDefinition("CMAKE_EXTRA_SHARED_LIBRARY_SUFFIXES")) {
std::vector<std::string> sharedSuffixVec = cmExpandedList(sharedSuffixes);
std::vector<std::string> sharedSuffixVec = cmExpandedList(*sharedSuffixes);
for (std::string const& i : sharedSuffixVec) {
this->AddLinkExtension(i, LinkShared);
}
@@ -1553,10 +1552,10 @@ void cmComputeLinkInformation::LoadImplicitLinkInfo()
// Append library architecture to all implicit platform directories
// and add them to the set
if (const char* libraryArch =
if (cmProp libraryArch =
this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE")) {
for (std::string const& i : implicitDirVec) {
this->ImplicitLinkDirs.insert(i + "/" + libraryArch);
this->ImplicitLinkDirs.insert(i + "/" + *libraryArch);
}
}
@@ -1746,14 +1745,13 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
}
if (use_build_rpath || use_link_rpath) {
std::string rootPath;
if (const char* sysrootLink =
if (cmProp sysrootLink =
this->Makefile->GetDefinition("CMAKE_SYSROOT_LINK")) {
rootPath = sysrootLink;
rootPath = *sysrootLink;
} else {
rootPath = this->Makefile->GetSafeDefinition("CMAKE_SYSROOT");
}
const char* stagePath =
this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX");
cmProp stagePath = this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX");
std::string const& installPrefix =
this->Makefile->GetSafeDefinition("CMAKE_INSTALL_PREFIX");
cmSystemTools::ConvertToUnixSlashes(rootPath);
@@ -1767,8 +1765,8 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
std::string d = ri;
if (!rootPath.empty() && cmHasPrefix(d, rootPath)) {
d.erase(0, rootPath.size());
} else if (cmNonempty(stagePath) && cmHasPrefix(d, stagePath)) {
d.erase(0, strlen(stagePath));
} else if (cmNonempty(stagePath) && cmHasPrefix(d, *stagePath)) {
d.erase(0, (*stagePath).size());
d = cmStrCat(installPrefix, '/', d);
cmSystemTools::ConvertToUnixSlashes(d);
} else if (use_relative_build_rpath) {
@@ -1798,8 +1796,8 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
std::string d = ri;
if (!rootPath.empty() && cmHasPrefix(d, rootPath)) {
d.erase(0, rootPath.size());
} else if (cmNonempty(stagePath) && cmHasPrefix(d, stagePath)) {
d.erase(0, strlen(stagePath));
} else if (cmNonempty(stagePath) && cmHasPrefix(d, *stagePath)) {
d.erase(0, (*stagePath).size());
d = cmStrCat(installPrefix, '/', d);
cmSystemTools::ConvertToUnixSlashes(d);
}
@@ -1821,7 +1819,7 @@ void cmComputeLinkInformation::GetRPath(std::vector<std::string>& runtimeDirs,
"CMAKE_" + li + "_USE_IMPLICIT_LINK_DIRECTORIES_IN_RUNTIME_PATH";
if (this->Makefile->IsOn(useVar)) {
std::string dirVar = "CMAKE_" + li + "_IMPLICIT_LINK_DIRECTORIES";
if (cmProp dirs = this->Makefile->GetDef(dirVar)) {
if (cmProp dirs = this->Makefile->GetDefinition(dirVar)) {
cmCLI_ExpandListUnique(*dirs, runtimeDirs, emitted);
}
}
Source/cmConditionEvaluator.cxx
+4 -3
View File
@@ -15,6 +15,7 @@
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmProperty.h"
#include "cmState.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
@@ -143,7 +144,7 @@ const char* cmConditionEvaluator::GetDefinitionIfUnquoted(
return nullptr;
}
const char* def = this->Makefile.GetDefinition(argument.GetValue());
cmProp def = this->Makefile.GetDefinition(argument.GetValue());
if (def && argument.WasQuoted() &&
this->Policy54Status == cmPolicies::WARN) {
@@ -161,7 +162,7 @@ const char* cmConditionEvaluator::GetDefinitionIfUnquoted(
}
}
return def;
return cmToCStr(def);
}
//=========================================================================
@@ -667,7 +668,7 @@ bool cmConditionEvaluator::HandleLevel2(cmArgumentList& newArgs,
bool result = false;
def = this->GetVariableOrString(*arg);
def2 = this->Makefile.GetDefinition(argP2->GetValue());
def2 = cmToCStr(this->Makefile.GetDefinition(argP2->GetValue()));
if (def2) {
std::vector<std::string> list = cmExpandedList(def2, true);
Source/cmCoreTryCompile.cxx
+30 -31
View File
@@ -238,7 +238,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
this->SrcFileSignature = true;
cmStateEnums::TargetType targetType = cmStateEnums::EXECUTABLE;
cmProp tt = this->Makefile->GetDef("CMAKE_TRY_COMPILE_TARGET_TYPE");
cmProp tt = this->Makefile->GetDefinition("CMAKE_TRY_COMPILE_TARGET_TYPE");
if (!isTryRun && cmNonempty(tt)) {
if (*tt == cmState::GetTargetTypeName(cmStateEnums::EXECUTABLE)) {
targetType = cmStateEnums::EXECUTABLE;
@@ -527,19 +527,19 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
return -1;
}
const char* def = this->Makefile->GetDefinition("CMAKE_MODULE_PATH");
cmProp def = this->Makefile->GetDefinition("CMAKE_MODULE_PATH");
fprintf(fout, "cmake_minimum_required(VERSION %u.%u.%u.%u)\n",
cmVersion::GetMajorVersion(), cmVersion::GetMinorVersion(),
cmVersion::GetPatchVersion(), cmVersion::GetTweakVersion());
if (def) {
fprintf(fout, "set(CMAKE_MODULE_PATH \"%s\")\n", def);
fprintf(fout, "set(CMAKE_MODULE_PATH \"%s\")\n", def->c_str());
}
/* Set MSVC runtime library policy to match our selection. */
if (const char* msvcRuntimeLibraryDefault =
if (cmProp msvcRuntimeLibraryDefault =
this->Makefile->GetDefinition(kCMAKE_MSVC_RUNTIME_LIBRARY_DEFAULT)) {
fprintf(fout, "cmake_policy(SET CMP0091 %s)\n",
*msvcRuntimeLibraryDefault ? "NEW" : "OLD");
!msvcRuntimeLibraryDefault->empty() ? "NEW" : "OLD");
}
/* Set CUDA architectures policy to match outer project. */
@@ -555,14 +555,14 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
projectLangs += " " + li;
std::string rulesOverrideBase = "CMAKE_USER_MAKE_RULES_OVERRIDE";
std::string rulesOverrideLang = cmStrCat(rulesOverrideBase, "_", li);
if (const char* rulesOverridePath =
if (cmProp rulesOverridePath =
this->Makefile->GetDefinition(rulesOverrideLang)) {
fprintf(fout, "set(%s \"%s\")\n", rulesOverrideLang.c_str(),
rulesOverridePath);
} else if (const char* rulesOverridePath2 =
rulesOverridePath->c_str());
} else if (cmProp rulesOverridePath2 =
this->Makefile->GetDefinition(rulesOverrideBase)) {
fprintf(fout, "set(%s \"%s\")\n", rulesOverrideBase.c_str(),
rulesOverridePath2);
rulesOverridePath2->c_str());
}
}
fprintf(fout, "project(CMAKE_TRY_COMPILE%s)\n", projectLangs.c_str());
@@ -577,9 +577,9 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
fprintf(fout, "set(CMAKE_VERBOSE_MAKEFILE 1)\n");
for (std::string const& li : testLangs) {
std::string langFlags = "CMAKE_" + li + "_FLAGS";
const char* flags = this->Makefile->GetDefinition(langFlags);
cmProp flags = this->Makefile->GetDefinition(langFlags);
fprintf(fout, "set(CMAKE_%s_FLAGS %s)\n", li.c_str(),
cmOutputConverter::EscapeForCMake(flags ? flags : "").c_str());
cmOutputConverter::EscapeForCMake(cmToCStrSafe(flags)).c_str());
fprintf(fout,
"set(CMAKE_%s_FLAGS \"${CMAKE_%s_FLAGS}"
" ${COMPILE_DEFINITIONS}\")\n",
@@ -616,10 +616,10 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
for (std::string const& li : testLangs) {
std::string const langFlagsCfg =
cmStrCat("CMAKE_", li, "_FLAGS_", cfg);
const char* flagsCfg = this->Makefile->GetDefinition(langFlagsCfg);
fprintf(fout, "set(%s %s)\n", langFlagsCfg.c_str(),
cmOutputConverter::EscapeForCMake(flagsCfg ? flagsCfg : "")
.c_str());
cmProp flagsCfg = this->Makefile->GetDefinition(langFlagsCfg);
fprintf(
fout, "set(%s %s)\n", langFlagsCfg.c_str(),
cmOutputConverter::EscapeForCMake(cmToCStrSafe(flagsCfg)).c_str());
}
} break;
}
@@ -649,12 +649,11 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
case cmPolicies::NEW:
// NEW behavior is to pass linker flags.
{
const char* exeLinkFlags =
cmProp exeLinkFlags =
this->Makefile->GetDefinition("CMAKE_EXE_LINKER_FLAGS");
fprintf(
fout, "set(CMAKE_EXE_LINKER_FLAGS %s)\n",
cmOutputConverter::EscapeForCMake(exeLinkFlags ? exeLinkFlags : "")
.c_str());
fprintf(fout, "set(CMAKE_EXE_LINKER_FLAGS %s)\n",
cmOutputConverter::EscapeForCMake(cmToCStrSafe(exeLinkFlags))
.c_str());
}
break;
}
@@ -730,9 +729,9 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
vars.insert(kCMAKE_WARN_DEPRECATED);
vars.emplace("CMAKE_MSVC_RUNTIME_LIBRARY"_s);
if (const char* varListStr = this->Makefile->GetDefinition(
if (cmProp varListStr = this->Makefile->GetDefinition(
kCMAKE_TRY_COMPILE_PLATFORM_VARIABLES)) {
std::vector<std::string> varList = cmExpandedList(varListStr);
std::vector<std::string> varList = cmExpandedList(*varListStr);
vars.insert(varList.begin(), varList.end());
}
@@ -767,16 +766,16 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
cmLocalGenerator doesn't allow building for "the other"
architecture only via CMAKE_OSX_ARCHITECTURES.
*/
if (const char* tcArchs = this->Makefile->GetDefinition(
if (cmProp tcArchs = this->Makefile->GetDefinition(
kCMAKE_TRY_COMPILE_OSX_ARCHITECTURES)) {
vars.erase(kCMAKE_OSX_ARCHITECTURES);
std::string flag = "-DCMAKE_OSX_ARCHITECTURES=" + std::string(tcArchs);
std::string flag = "-DCMAKE_OSX_ARCHITECTURES=" + *tcArchs;
cmakeFlags.push_back(std::move(flag));
}
for (std::string const& var : vars) {
if (const char* val = this->Makefile->GetDefinition(var)) {
std::string flag = "-D" + var + "=" + val;
if (cmProp val = this->Makefile->GetDefinition(var)) {
std::string flag = "-D" + var + "=" + *val;
cmakeFlags.push_back(std::move(flag));
}
}
@@ -916,8 +915,8 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
if (this->Makefile->GetState()->UseGhsMultiIDE()) {
// Forward the GHS variables to the inner project cache.
for (std::string const& var : ghs_platform_vars) {
if (const char* val = this->Makefile->GetDefinition(var)) {
std::string flag = "-D" + var + "=" + "'" + val + "'";
if (cmProp val = this->Makefile->GetDefinition(var)) {
std::string flag = "-D" + var + "=" + "'" + *val + "'";
cmakeFlags.push_back(std::move(flag));
}
}
@@ -1054,18 +1053,18 @@ void cmCoreTryCompile::FindOutputFile(const std::string& targetName,
std::vector<std::string> searchDirs;
searchDirs.emplace_back();
const char* config =
cmProp config =
this->Makefile->GetDefinition("CMAKE_TRY_COMPILE_CONFIGURATION");
// if a config was specified try that first
if (cmNonempty(config)) {
std::string tmp = cmStrCat('/', config);
std::string tmp = cmStrCat('/', *config);
searchDirs.push_back(std::move(tmp));
}
searchDirs.emplace_back("/Debug");
#if defined(__APPLE__)
std::string app = "/" + targetName + ".app";
if (cmNonempty(config)) {
std::string tmp = cmStrCat('/', config, app);
std::string tmp = cmStrCat('/', *config, app);
searchDirs.push_back(std::move(tmp));
}
std::string tmp = "/Debug" + app;
Source/cmDepends.cxx
+4 -3
View File
@@ -11,6 +11,7 @@
#include "cmGeneratedFileStream.h"
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
@@ -228,19 +229,19 @@ bool cmDepends::CheckDependencies(std::istream& internalDepends,
void cmDepends::SetIncludePathFromLanguage(const std::string& lang)
{
// Look for the new per "TARGET_" variant first:
const char* includePath = nullptr;
cmProp includePath = nullptr;
std::string includePathVar =
cmStrCat("CMAKE_", lang, "_TARGET_INCLUDE_PATH");
cmMakefile* mf = this->LocalGenerator->GetMakefile();
includePath = mf->GetDefinition(includePathVar);
if (includePath) {
cmExpandList(includePath, this->IncludePath);
cmExpandList(*includePath, this->IncludePath);
} else {
// Fallback to the old directory level variable if no per-target var:
includePathVar = cmStrCat("CMAKE_", lang, "_INCLUDE_PATH");
includePath = mf->GetDefinition(includePathVar);
if (includePath) {
cmExpandList(includePath, this->IncludePath);
cmExpandList(*includePath, this->IncludePath);
}
}
}
Source/cmDependsC.cxx
+5 -4
View File
@@ -9,6 +9,7 @@
#include "cmFileTime.h"
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
@@ -38,13 +39,13 @@ cmDependsC::cmDependsC(cmLocalUnixMakefileGenerator3* lg,
std::string complainRegex = "^$";
{
std::string scanRegexVar = cmStrCat("CMAKE_", lang, "_INCLUDE_REGEX_SCAN");
if (const char* sr = mf->GetDefinition(scanRegexVar)) {
scanRegex = sr;
if (cmProp sr = mf->GetDefinition(scanRegexVar)) {
scanRegex = *sr;
}
std::string complainRegexVar =
cmStrCat("CMAKE_", lang, "_INCLUDE_REGEX_COMPLAIN");
if (const char* cr = mf->GetDefinition(complainRegexVar)) {
complainRegex = cr;
if (cmProp cr = mf->GetDefinition(complainRegexVar)) {
complainRegex = *cr;
}
}
Source/cmDependsFortran.cxx
+3 -2
View File
@@ -15,6 +15,7 @@
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
#include "cmOutputConverter.h"
#include "cmProperty.h"
#include "cmStateDirectory.h"
#include "cmStateSnapshot.h"
#include "cmStringAlgorithms.h"
@@ -394,9 +395,9 @@ bool cmDependsFortran::WriteDependenciesReal(std::string const& obj,
makeDepends << "\t$(CMAKE_COMMAND) -E cmake_copy_f90_mod " << modFile
<< ' ' << stampFileForShell;
cmMakefile* mf = this->LocalGenerator->GetMakefile();
const char* cid = mf->GetDefinition("CMAKE_Fortran_COMPILER_ID");
cmProp cid = mf->GetDefinition("CMAKE_Fortran_COMPILER_ID");
if (cmNonempty(cid)) {
makeDepends << ' ' << cid;
makeDepends << ' ' << *cid;
}
makeDepends << '\n';
}
Source/cmExtraCodeBlocksGenerator.cxx
+7 -6
View File
@@ -16,6 +16,7 @@
#include "cmGlobalGenerator.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmRange.h"
#include "cmSourceFile.h"
#include "cmStateTypes.h"
@@ -496,15 +497,15 @@ void cmExtraCodeBlocksGenerator::AppendTarget(
if (target->GetType() == cmStateEnums::EXECUTABLE) {
// Determine the directory where the executable target is created, and
// set the working directory to this dir.
const char* runtimeOutputDir =
cmProp runtimeOutputDir =
makefile->GetDefinition("CMAKE_RUNTIME_OUTPUT_DIRECTORY");
if (runtimeOutputDir != nullptr) {
workingDir = runtimeOutputDir;
if (runtimeOutputDir) {
workingDir = *runtimeOutputDir;
} else {
const char* executableOutputDir =
cmProp executableOutputDir =
makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH");
if (executableOutputDir != nullptr) {
workingDir = executableOutputDir;
if (executableOutputDir) {
workingDir = *executableOutputDir;
}
}
}
Source/cmExtraEclipseCDT4Generator.cxx
+6 -6
View File
@@ -189,9 +189,9 @@ void cmExtraEclipseCDT4Generator::CreateSettingsResourcePrefsFile()
}
fout << "eclipse.preferences.version=1\n";
const char* encoding = mf->GetDefinition("CMAKE_ECLIPSE_RESOURCE_ENCODING");
cmProp encoding = mf->GetDefinition("CMAKE_ECLIPSE_RESOURCE_ENCODING");
if (encoding) {
fout << "encoding/<project>=" << encoding << '\n';
fout << "encoding/<project>=" << *encoding << '\n';
}
}
@@ -793,11 +793,11 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
}
}
// add system defined c macros
const char* cDefs =
cmProp cDefs =
mf->GetDefinition("CMAKE_EXTRA_GENERATOR_C_SYSTEM_DEFINED_MACROS");
if (this->CEnabled && cDefs) {
// Expand the list.
std::vector<std::string> defs = cmExpandedList(cDefs, true);
std::vector<std::string> defs = cmExpandedList(*cDefs, true);
// the list must contain only definition-value pairs:
if ((defs.size() % 2) == 0) {
@@ -825,11 +825,11 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
}
}
// add system defined c++ macros
const char* cxxDefs =
cmProp cxxDefs =
mf->GetDefinition("CMAKE_EXTRA_GENERATOR_CXX_SYSTEM_DEFINED_MACROS");
if (this->CXXEnabled && cxxDefs) {
// Expand the list.
std::vector<std::string> defs = cmExpandedList(cxxDefs, true);
std::vector<std::string> defs = cmExpandedList(*cxxDefs, true);
// the list must contain only definition-value pairs:
if ((defs.size() % 2) == 0) {
Source/cmExtraKateGenerator.cxx
+3 -2
View File
@@ -13,6 +13,7 @@
#include "cmGlobalGenerator.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmSourceFile.h"
#include "cmStateTypes.h"
#include "cmStringAlgorithms.h"
@@ -127,10 +128,10 @@ void cmExtraKateGenerator::WriteTargets(const cmLocalGenerator& lg,
// only add the "edit_cache" target if it's not ccmake, because
// this will not work within the IDE
if (targetName == "edit_cache") {
const char* editCommand =
cmProp editCommand =
localGen->GetMakefile()->GetDefinition("CMAKE_EDIT_COMMAND");
if (editCommand == nullptr ||
strstr(editCommand, "ccmake") != nullptr) {
strstr(editCommand->c_str(), "ccmake") != nullptr) {
insertTarget = false;
}
}
Source/cmFileAPICodemodel.cxx
+8 -8
View File
@@ -852,12 +852,12 @@ void Target::ProcessLanguage(std::string const& lang)
{
CompileData& cd = this->CompileDataMap[lang];
cd.Language = lang;
if (const char* sysrootCompile =
if (cmProp sysrootCompile =
this->GT->Makefile->GetDefinition("CMAKE_SYSROOT_COMPILE")) {
cd.Sysroot = sysrootCompile;
} else if (const char* sysroot =
cd.Sysroot = *sysrootCompile;
} else if (cmProp sysroot =
this->GT->Makefile->GetDefinition("CMAKE_SYSROOT")) {
cd.Sysroot = sysroot;
cd.Sysroot = *sysroot;
}
cmLocalGenerator* lg = this->GT->GetLocalGenerator();
{
@@ -1404,12 +1404,12 @@ Json::Value Target::DumpLink()
link["commandFragments"] = std::move(commandFragments);
}
}
if (const char* sysrootLink =
if (cmProp sysrootLink =
this->GT->Makefile->GetDefinition("CMAKE_SYSROOT_LINK")) {
link["sysroot"] = this->DumpSysroot(sysrootLink);
} else if (const char* sysroot =
link["sysroot"] = this->DumpSysroot(*sysrootLink);
} else if (cmProp sysroot =
this->GT->Makefile->GetDefinition("CMAKE_SYSROOT")) {
link["sysroot"] = this->DumpSysroot(sysroot);
link["sysroot"] = this->DumpSysroot(*sysroot);
}
if (this->GT->IsIPOEnabled(lang, this->Config)) {
link["lto"] = true;
Source/cmFileCommand.cxx
+7 -6
View File
@@ -44,6 +44,7 @@
#include "cmMessageType.h"
#include "cmNewLineStyle.h"
#include "cmPolicies.h"
#include "cmProperty.h"
#include "cmRange.h"
#include "cmRuntimeDependencyArchive.h"
#include "cmState.h"
@@ -1568,7 +1569,7 @@ bool HandleDownloadCommand(std::vector<std::string> const& args,
std::string logVar;
std::string statusVar;
bool tls_verify = status.GetMakefile().IsOn("CMAKE_TLS_VERIFY");
const char* cainfo = status.GetMakefile().GetDefinition("CMAKE_TLS_CAINFO");
cmProp cainfo = status.GetMakefile().GetDefinition("CMAKE_TLS_CAINFO");
std::string netrc_level =
status.GetMakefile().GetSafeDefinition("CMAKE_NETRC");
std::string netrc_file =
@@ -1623,7 +1624,7 @@ bool HandleDownloadCommand(std::vector<std::string> const& args,
} else if (*i == "TLS_CAINFO") {
++i;
if (i != args.end()) {
cainfo = i->c_str();
cainfo = &(*i);
} else {
status.SetError("DOWNLOAD missing file value for TLS_CAINFO.");
return false;
@@ -1790,7 +1791,7 @@ bool HandleDownloadCommand(std::vector<std::string> const& args,
// check to see if a CAINFO file has been specified
// command arg comes first
std::string const& cainfo_err = cmCurlSetCAInfo(curl, cainfo);
std::string const& cainfo_err = cmCurlSetCAInfo(curl, cmToCStr(cainfo));
if (!cainfo_err.empty()) {
status.SetError(cainfo_err);
return false;
@@ -1956,7 +1957,7 @@ bool HandleUploadCommand(std::vector<std::string> const& args,
std::string statusVar;
bool showProgress = false;
bool tls_verify = status.GetMakefile().IsOn("CMAKE_TLS_VERIFY");
const char* cainfo = status.GetMakefile().GetDefinition("CMAKE_TLS_CAINFO");
cmProp cainfo = status.GetMakefile().GetDefinition("CMAKE_TLS_CAINFO");
std::string userpwd;
std::string netrc_level =
status.GetMakefile().GetSafeDefinition("CMAKE_NETRC");
@@ -2009,7 +2010,7 @@ bool HandleUploadCommand(std::vector<std::string> const& args,
} else if (*i == "TLS_CAINFO") {
++i;
if (i != args.end()) {
cainfo = i->c_str();
cainfo = &(*i);
} else {
status.SetError("UPLOAD missing file value for TLS_CAINFO.");
return false;
@@ -2110,7 +2111,7 @@ bool HandleUploadCommand(std::vector<std::string> const& args,
// check to see if a CAINFO file has been specified
// command arg comes first
std::string const& cainfo_err = cmCurlSetCAInfo(curl, cainfo);
std::string const& cainfo_err = cmCurlSetCAInfo(curl, cmToCStr(cainfo));
if (!cainfo_err.empty()) {
status.SetError(cainfo_err);
return false;
Source/cmFileCopier.cxx
+3 -2
View File
@@ -10,6 +10,7 @@
#include "cmFSPermissions.h"
#include "cmFileTimes.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
@@ -171,11 +172,11 @@ void cmFileCopier::DefaultDirectoryPermissions()
bool cmFileCopier::GetDefaultDirectoryPermissions(mode_t** mode)
{
// check if default dir creation permissions were set
const char* default_dir_install_permissions = this->Makefile->GetDefinition(
cmProp default_dir_install_permissions = this->Makefile->GetDefinition(
"CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS");
if (cmNonempty(default_dir_install_permissions)) {
std::vector<std::string> items =
cmExpandedList(default_dir_install_permissions);
cmExpandedList(*default_dir_install_permissions);
for (const auto& arg : items) {
if (!this->CheckPermissions(arg, **mode)) {
this->Status.SetError(
Source/cmFindBase.cxx
+2 -3
View File
@@ -294,11 +294,10 @@ void cmFindBase::FillUserGuessPath()
bool cmFindBase::CheckForVariableInCache()
{
if (const char* cacheValue =
this->Makefile->GetDefinition(this->VariableName)) {
if (cmProp cacheValue = this->Makefile->GetDefinition(this->VariableName)) {
cmState* state = this->Makefile->GetState();
cmProp cacheEntry = state->GetCacheEntryValue(this->VariableName);
bool found = !cmIsNOTFOUND(cacheValue);
bool found = !cmIsNOTFOUND(*cacheValue);
bool cached = cacheEntry != nullptr;
if (found) {
// If the user specifies the entry on the command line without a
Source/cmFindCommon.cxx
+13 -14
View File
@@ -11,6 +11,7 @@
#include "cmExecutionStatus.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmProperty.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmake.h"
@@ -182,9 +183,9 @@ void cmFindCommon::SelectDefaultSearchModes()
};
for (auto& path : search_paths) {
const char* def = this->Makefile->GetDefinition(path.second);
cmProp def = this->Makefile->GetDefinition(path.second);
if (def) {
path.first = !cmIsOn(def);
path.first = !cmIsOn(*def);
}
}
}
@@ -202,12 +203,11 @@ void cmFindCommon::RerootPaths(std::vector<std::string>& paths)
return;
}
const char* sysroot = this->Makefile->GetDefinition("CMAKE_SYSROOT");
const char* sysrootCompile =
cmProp sysroot = this->Makefile->GetDefinition("CMAKE_SYSROOT");
cmProp sysrootCompile =
this->Makefile->GetDefinition("CMAKE_SYSROOT_COMPILE");
const char* sysrootLink =
this->Makefile->GetDefinition("CMAKE_SYSROOT_LINK");
const char* rootPath = this->Makefile->GetDefinition("CMAKE_FIND_ROOT_PATH");
cmProp sysrootLink = this->Makefile->GetDefinition("CMAKE_SYSROOT_LINK");
cmProp rootPath = this->Makefile->GetDefinition("CMAKE_FIND_ROOT_PATH");
const bool noSysroot = !cmNonempty(sysroot);
const bool noCompileSysroot = !cmNonempty(sysrootCompile);
const bool noLinkSysroot = !cmNonempty(sysrootLink);
@@ -219,23 +219,22 @@ void cmFindCommon::RerootPaths(std::vector<std::string>& paths)
// Construct the list of path roots with no trailing slashes.
std::vector<std::string> roots;
if (rootPath) {
cmExpandList(rootPath, roots);
cmExpandList(*rootPath, roots);
}
if (sysrootCompile) {
roots.emplace_back(sysrootCompile);
roots.emplace_back(*sysrootCompile);
}
if (sysrootLink) {
roots.emplace_back(sysrootLink);
roots.emplace_back(*sysrootLink);
}
if (sysroot) {
roots.emplace_back(sysroot);
roots.emplace_back(*sysroot);
}
for (std::string& r : roots) {
cmSystemTools::ConvertToUnixSlashes(r);
}
const char* stagePrefix =
this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX");
cmProp stagePrefix = this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX");
// Copy the original set of unrooted paths.
std::vector<std::string> unrootedPaths = paths;
@@ -248,7 +247,7 @@ void cmFindCommon::RerootPaths(std::vector<std::string>& paths)
// a user home directory or is empty.
std::string rootedDir;
if (cmSystemTools::IsSubDirectory(up, r) ||
(stagePrefix && cmSystemTools::IsSubDirectory(up, stagePrefix))) {
(stagePrefix && cmSystemTools::IsSubDirectory(up, *stagePrefix))) {
rootedDir = up;
} else if (!up.empty() && up[0] != '~') {
// Start with the new root.
Source/cmFindLibraryCommand.cxx
+3 -2
View File
@@ -13,6 +13,7 @@
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmProperty.h"
#include "cmState.h"
#include "cmStateTypes.h"
#include "cmStringAlgorithms.h"
@@ -50,9 +51,9 @@ bool cmFindLibraryCommand::InitialPass(std::vector<std::string> const& argsIn)
// add custom lib<qual> paths instead of using fixed lib32, lib64 or
// libx32
if (const char* customLib = this->Makefile->GetDefinition(
if (cmProp customLib = this->Makefile->GetDefinition(
"CMAKE_FIND_LIBRARY_CUSTOM_LIB_SUFFIX")) {
this->AddArchitecturePaths(customLib);
this->AddArchitecturePaths(customLib->c_str());
}
// add special 32 bit paths if this is a 32 bit compile.
else if (this->Makefile->PlatformIs32Bit() &&
Source/cmFindPackageCommand.cxx
+17 -17
View File
@@ -154,10 +154,10 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
}
// Lookup required version of CMake.
if (const char* rv =
if (cmProp rv =
this->Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION")) {
unsigned int v[3] = { 0, 0, 0 };
sscanf(rv, "%u.%u.%u", &v[0], &v[1], &v[2]);
sscanf(rv->c_str(), "%u.%u.%u", &v[0], &v[1], &v[2]);
this->RequiredCMakeVersion = CMake_VERSION_ENCODE(v[0], v[1], v[2]);
}
@@ -165,9 +165,9 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
this->DebugBuffer.clear();
// Lookup target architecture, if any.
if (const char* arch =
if (cmProp arch =
this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE")) {
this->LibraryArchitecture = arch;
this->LibraryArchitecture = *arch;
}
// Lookup whether lib32 paths should be used.
@@ -194,9 +194,9 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
// Check if User Package Registry should be disabled
// The `CMAKE_FIND_USE_PACKAGE_REGISTRY` has
// priority over the deprecated CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY
if (const char* def =
if (cmProp def =
this->Makefile->GetDefinition("CMAKE_FIND_USE_PACKAGE_REGISTRY")) {
this->NoUserRegistry = !cmIsOn(def);
this->NoUserRegistry = !cmIsOn(*def);
} else if (this->Makefile->IsOn("CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY")) {
this->NoUserRegistry = true;
}
@@ -204,9 +204,9 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
// Check if System Package Registry should be disabled
// The `CMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY` has
// priority over the deprecated CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY
if (const char* def = this->Makefile->GetDefinition(
if (cmProp def = this->Makefile->GetDefinition(
"CMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY")) {
this->NoSystemRegistry = !cmIsOn(def);
this->NoSystemRegistry = !cmIsOn(*def);
} else if (this->Makefile->IsOn(
"CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY")) {
this->NoSystemRegistry = true;
@@ -218,20 +218,20 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args)
}
// Check if Sorting should be enabled
if (const char* so =
if (cmProp so =
this->Makefile->GetDefinition("CMAKE_FIND_PACKAGE_SORT_ORDER")) {
if (strcmp(so, "NAME") == 0) {
if (*so == "NAME") {
this->SortOrder = Name_order;
} else if (strcmp(so, "NATURAL") == 0) {
} else if (*so == "NATURAL") {
this->SortOrder = Natural;
} else {
this->SortOrder = None;
}
}
if (const char* sd =
if (cmProp sd =
this->Makefile->GetDefinition("CMAKE_FIND_PACKAGE_SORT_DIRECTION")) {
this->SortDirection = strcmp(sd, "ASC") == 0 ? Asc : Dec;
this->SortDirection = (*sd == "ASC") ? Asc : Dec;
}
// Find what search path locations have been enabled/disable
@@ -675,9 +675,9 @@ void cmFindPackageCommand::SetModuleVariables(const std::string& components)
void cmFindPackageCommand::AddFindDefinition(const std::string& var,
const char* val)
{
if (const char* old = this->Makefile->GetDefinition(var)) {
if (cmProp old = this->Makefile->GetDefinition(var)) {
this->OriginalDefs[var].exists = true;
this->OriginalDefs[var].value = old;
this->OriginalDefs[var].value = *old;
} else {
this->OriginalDefs[var].exists = false;
}
@@ -759,14 +759,14 @@ bool cmFindPackageCommand::HandlePackageMode(
this->ConsideredConfigs.clear();
// Try to find the config file.
const char* def = this->Makefile->GetDefinition(this->Variable);
cmProp def = this->Makefile->GetDefinition(this->Variable);
// Try to load the config file if the directory is known
bool fileFound = false;
if (this->UseConfigFiles) {
if (!cmIsOff(def)) {
// Get the directory from the variable value.
std::string dir = def;
std::string dir = *def;
cmSystemTools::ConvertToUnixSlashes(dir);
// Treat relative paths with respect to the current source dir.
Source/cmForEachCommand.cxx
+5 -4
View File
@@ -25,6 +25,7 @@
#include "cmListFileCache.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmProperty.h"
#include "cmRange.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
@@ -113,8 +114,8 @@ bool cmForEachFunctionBlocker::ReplayItems(
// At end of for each execute recorded commands
// store the old value
std::string oldDef;
if (auto d = mf.GetDefinition(this->Args.front())) {
oldDef = d;
if (cmProp d = mf.GetDefinition(this->Args.front())) {
oldDef = *d;
}
auto restore = false;
@@ -186,8 +187,8 @@ bool cmForEachFunctionBlocker::ReplayZipLists(
// Store old values for iteration variables
std::map<std::string, std::string> oldDefs;
for (auto i = 0u; i < values.size(); ++i) {
if (auto d = mf.GetDefinition(iterationVars[i])) {
oldDefs.emplace(iterationVars[i], d);
if (cmProp d = mf.GetDefinition(iterationVars[i])) {
oldDefs.emplace(iterationVars[i], *d);
}
}
Source/cmGeneratorExpressionNode.cxx
+1 -1
View File
@@ -1741,7 +1741,7 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode
for (auto const& lit : testedFeatures) {
std::vector<std::string> const& langAvailable =
availableFeatures[lit.first];
cmProp standardDefault = context->LG->GetMakefile()->GetDef(
cmProp standardDefault = context->LG->GetMakefile()->GetDefinition(
"CMAKE_" + lit.first + "_STANDARD_DEFAULT");
for (std::string const& it : lit.second) {
if (!cm::contains(langAvailable, it)) {
Source/cmGeneratorTarget.cxx
+17 -17
View File
@@ -625,13 +625,13 @@ const char* cmGeneratorTarget::GetFilePrefixInternal(
const char* prefixVar = this->Target->GetPrefixVariableInternal(artifact);
if (!language.empty() && prefixVar && *prefixVar) {
std::string langPrefix = prefixVar + std::string("_") + language;
targetPrefix = this->Makefile->GetDef(langPrefix);
targetPrefix = this->Makefile->GetDefinition(langPrefix);
}
// if there is no prefix on the target nor specific language
// use the cmake definition.
if (!targetPrefix && prefixVar) {
targetPrefix = this->Makefile->GetDef(prefixVar);
targetPrefix = this->Makefile->GetDefinition(prefixVar);
}
}
@@ -675,13 +675,13 @@ const char* cmGeneratorTarget::GetFileSuffixInternal(
const char* suffixVar = this->Target->GetSuffixVariableInternal(artifact);
if (!language.empty() && suffixVar && *suffixVar) {
std::string langSuffix = suffixVar + std::string("_") + language;
targetSuffix = this->Makefile->GetDef(langSuffix);
targetSuffix = this->Makefile->GetDefinition(langSuffix);
}
// if there is no suffix on the target nor specific language
// use the cmake definition.
if (!targetSuffix && suffixVar) {
targetSuffix = this->Makefile->GetDef(suffixVar);
targetSuffix = this->Makefile->GetDefinition(suffixVar);
}
}
@@ -1167,10 +1167,10 @@ const std::string& cmGeneratorTarget::GetLocationForBuild() const
// Now handle the deprecated build-time configuration location.
std::string const noConfig;
location = this->GetDirectory(noConfig);
const char* cfgid = this->Makefile->GetDefinition("CMAKE_CFG_INTDIR");
if (cfgid && strcmp(cfgid, ".") != 0) {
cmProp cfgid = this->Makefile->GetDefinition("CMAKE_CFG_INTDIR");
if (cfgid && (*cfgid != ".")) {
location += "/";
location += cfgid;
location += *cfgid;
}
if (this->IsAppBundleOnApple()) {
@@ -2065,13 +2065,13 @@ bool cmGeneratorTarget::IsChrpathUsed(const std::string& config) const
if (!ll.empty()) {
std::string sepVar =
cmStrCat("CMAKE_SHARED_LIBRARY_RUNTIME_", ll, "_FLAG_SEP");
const char* sep = this->Makefile->GetDefinition(sepVar);
cmProp sep = this->Makefile->GetDefinition(sepVar);
if (cmNonempty(sep)) {
// TODO: Add ELF check to ABI detection and get rid of
// CMAKE_EXECUTABLE_FORMAT.
if (const char* fmt =
if (cmProp fmt =
this->Makefile->GetDefinition("CMAKE_EXECUTABLE_FORMAT")) {
return strcmp(fmt, "ELF") == 0;
return (*fmt == "ELF");
}
}
}
@@ -3909,8 +3909,8 @@ std::string cmGeneratorTarget::GetPchHeader(const std::string& config,
const std::string filename_tmp = cmStrCat(filename, ".tmp");
if (!pchReuseFrom) {
auto pchPrologue = this->Makefile->GetDefinition("CMAKE_PCH_PROLOGUE");
auto pchEpilogue = this->Makefile->GetDefinition("CMAKE_PCH_EPILOGUE");
cmProp pchPrologue = this->Makefile->GetDefinition("CMAKE_PCH_PROLOGUE");
cmProp pchEpilogue = this->Makefile->GetDefinition("CMAKE_PCH_EPILOGUE");
std::string firstHeaderOnDisk;
{
@@ -3919,7 +3919,7 @@ std::string cmGeneratorTarget::GetPchHeader(const std::string& config,
this->GetGlobalGenerator()->GetMakefileEncoding());
file << "/* generated by CMake */\n\n";
if (pchPrologue) {
file << pchPrologue << "\n";
file << *pchPrologue << "\n";
}
if (this->GetGlobalGenerator()->IsXcode()) {
file << "#ifndef CMAKE_SKIP_PRECOMPILE_HEADERS\n";
@@ -3949,7 +3949,7 @@ std::string cmGeneratorTarget::GetPchHeader(const std::string& config,
file << "#endif // CMAKE_SKIP_PRECOMPILE_HEADERS\n";
}
if (pchEpilogue) {
file << pchEpilogue << "\n";
file << *pchEpilogue << "\n";
}
}
@@ -4630,7 +4630,7 @@ bool cmGeneratorTarget::ComputeCompileFeatures(
this->LanguageStandardMap[key] = *standardToCopy;
generatorTargetLanguageStandard = &this->LanguageStandardMap[key];
} else {
cmProp defaultStandard = this->Makefile->GetDef(
cmProp defaultStandard = this->Makefile->GetDefinition(
cmStrCat("CMAKE_", language.second, "_STANDARD_DEFAULT"));
if (defaultStandard != nullptr) {
this->LanguageStandardMap[key] = BTs<std::string>(*defaultStandard);
@@ -5952,7 +5952,7 @@ std::string cmGeneratorTarget::GetRuntimeLinkLibrary(
{
// This is activated by the presence of a default selection whether or
// not it is overridden by a property.
cmProp runtimeLibraryDefault = this->Makefile->GetDef(
cmProp runtimeLibraryDefault = this->Makefile->GetDefinition(
cmStrCat("CMAKE_", lang, "_RUNTIME_LIBRARY_DEFAULT"));
if (!cmNonempty(runtimeLibraryDefault)) {
return std::string();
@@ -5992,7 +5992,7 @@ std::string cmGeneratorTarget::CreateFortranModuleDirectory(
target_mod_dir = default_mod_dir;
}
}
const char* moddir_flag =
cmProp moddir_flag =
this->Makefile->GetDefinition("CMAKE_Fortran_MODDIR_FLAG");
if (!target_mod_dir.empty() && moddir_flag) {
// Compute the full path to the module directory.
Source/cmGetFilenameComponentCommand.cxx
+3 -2
View File
@@ -4,6 +4,7 @@
#include "cmExecutionStatus.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmStateTypes.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
@@ -21,8 +22,8 @@ bool cmGetFilenameComponentCommand(std::vector<std::string> const& args,
// Check and see if the value has been stored in the cache
// already, if so use that value
if (args.size() >= 4 && args.back() == "CACHE") {
const char* cacheValue = status.GetMakefile().GetDefinition(args.front());
if (cacheValue && !cmIsNOTFOUND(cacheValue)) {
cmProp cacheValue = status.GetMakefile().GetDefinition(args.front());
if (cacheValue && !cmIsNOTFOUND(*cacheValue)) {
return true;
}
}
Source/cmGetPropertyCommand.cxx
+3 -2
View File
@@ -430,8 +430,9 @@ bool HandleVariableMode(cmExecutionStatus& status, const std::string& name,
return false;
}
return StoreResult(infoType, status.GetMakefile(), variable,
status.GetMakefile().GetDefinition(propertyName));
return StoreResult(
infoType, status.GetMakefile(), variable,
cmToCStr(status.GetMakefile().GetDefinition(propertyName)));
}
bool HandleCacheMode(cmExecutionStatus& status, const std::string& name,
Source/cmGhsMultiTargetGenerator.cxx
+2 -2
View File
@@ -43,9 +43,9 @@ cmGhsMultiTargetGenerator::cmGhsMultiTargetGenerator(cmGeneratorTarget* target)
#endif
{
// Store the configuration name that is being used
if (const char* config = this->Makefile->GetDefinition("CMAKE_BUILD_TYPE")) {
if (cmProp config = this->Makefile->GetDefinition("CMAKE_BUILD_TYPE")) {
// Use the build type given by the user.
this->ConfigName = config;
this->ConfigName = *config;
} else {
// No configuration type given.
this->ConfigName.clear();
Source/cmGlobalGenerator.cxx
+26 -28
View File
@@ -780,27 +780,27 @@ void cmGlobalGenerator::EnableLanguage(
std::string compilerName = cmStrCat("CMAKE_", lang, "_COMPILER");
std::string compilerEnv = cmStrCat("CMAKE_", lang, "_COMPILER_ENV_VAR");
std::ostringstream noCompiler;
const char* compilerFile = mf->GetDefinition(compilerName);
if (!cmNonempty(compilerFile) || cmIsNOTFOUND(compilerFile)) {
cmProp compilerFile = mf->GetDefinition(compilerName);
if (!cmNonempty(compilerFile) || cmIsNOTFOUND(*compilerFile)) {
/* clang-format off */
noCompiler <<
"No " << compilerName << " could be found.\n"
;
/* clang-format on */
} else if ((lang != "RC") && (lang != "ASM_MASM")) {
if (!cmSystemTools::FileIsFullPath(compilerFile)) {
if (!cmSystemTools::FileIsFullPath(*compilerFile)) {
/* clang-format off */
noCompiler <<
"The " << compilerName << ":\n"
" " << compilerFile << "\n"
" " << *compilerFile << "\n"
"is not a full path and was not found in the PATH.\n"
;
/* clang-format on */
} else if (!cmSystemTools::FileExists(compilerFile)) {
} else if (!cmSystemTools::FileExists(*compilerFile)) {
/* clang-format off */
noCompiler <<
"The " << compilerName << ":\n"
" " << compilerFile << "\n"
" " << *compilerFile << "\n"
"is not a full path to an existing compiler tool.\n"
;
/* clang-format on */
@@ -817,7 +817,7 @@ void cmGlobalGenerator::EnableLanguage(
cmSystemTools::RemoveFile(compilerLangFile);
if (!this->CMakeInstance->GetIsInTryCompile()) {
this->PrintCompilerAdvice(noCompiler, lang,
mf->GetDefinition(compilerEnv));
cmToCStr(mf->GetDefinition(compilerEnv)));
mf->IssueMessage(MessageType::FATAL_ERROR, noCompiler.str());
fatalError = true;
}
@@ -1095,17 +1095,16 @@ void cmGlobalGenerator::SetLanguageEnabledMaps(const std::string& l,
return;
}
std::string linkerPrefVar =
std::string("CMAKE_") + std::string(l) + std::string("_LINKER_PREFERENCE");
const char* linkerPref = mf->GetDefinition(linkerPrefVar);
std::string linkerPrefVar = "CMAKE_" + l + "_LINKER_PREFERENCE";
cmProp linkerPref = mf->GetDefinition(linkerPrefVar);
int preference = 0;
if (linkerPref) {
if (sscanf(linkerPref, "%d", &preference) != 1) {
if (cmNonempty(linkerPref)) {
if (sscanf(linkerPref->c_str(), "%d", &preference) != 1) {
// backward compatibility: before 2.6 LINKER_PREFERENCE
// was either "None" or "Preferred", and only the first character was
// tested. So if there is a custom language out there and it is
// "Preferred", set its preference high
if (linkerPref[0] == 'P') {
if ((*linkerPref)[0] == 'P') {
preference = 100;
} else {
preference = 0;
@@ -1122,14 +1121,14 @@ void cmGlobalGenerator::SetLanguageEnabledMaps(const std::string& l,
this->LanguageToLinkerPreference[l] = preference;
std::string outputExtensionVar =
std::string("CMAKE_") + std::string(l) + std::string("_OUTPUT_EXTENSION");
const char* outputExtension = mf->GetDefinition(outputExtensionVar);
if (outputExtension) {
std::string outputExtensionVar = "CMAKE_" + l + "_OUTPUT_EXTENSION";
if (cmProp p = mf->GetDefinition(outputExtensionVar)) {
std::string outputExtension = *p;
this->LanguageToOutputExtension[l] = outputExtension;
this->OutputExtensions[outputExtension] = outputExtension;
if (outputExtension[0] == '.') {
this->OutputExtensions[outputExtension + 1] = outputExtension + 1;
if (cmHasPrefix(outputExtension, ".")) {
outputExtension = outputExtension.substr(1);
this->OutputExtensions[outputExtension] = outputExtension;
}
}
@@ -1162,7 +1161,7 @@ void cmGlobalGenerator::FillExtensionToLanguageMap(const std::string& l,
const char* cmGlobalGenerator::GetGlobalSetting(std::string const& name) const
{
assert(!this->Makefiles.empty());
return this->Makefiles[0]->GetDefinition(name);
return cmToCStr(this->Makefiles[0]->GetDefinition(name));
}
bool cmGlobalGenerator::GlobalSettingIsOn(std::string const& name) const
@@ -2463,9 +2462,9 @@ void cmGlobalGenerator::AddGlobalTarget_Package(
if (this->GetPreinstallTargetName()) {
gti.Depends.emplace_back(this->GetPreinstallTargetName());
} else {
const char* noPackageAll =
cmProp noPackageAll =
mf->GetDefinition("CMAKE_SKIP_PACKAGE_ALL_DEPENDENCY");
if (!noPackageAll || cmIsOff(noPackageAll)) {
if (cmIsOff(noPackageAll)) {
gti.Depends.emplace_back(this->GetAllTargetName());
}
}
@@ -2644,9 +2643,8 @@ void cmGlobalGenerator::AddGlobalTarget_Install(
if (this->GetPreinstallTargetName()) {
gti.Depends.emplace_back(this->GetPreinstallTargetName());
} else {
const char* noall =
mf->GetDefinition("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY");
if (!noall || cmIsOff(noall)) {
cmProp noall = mf->GetDefinition("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY");
if (cmIsOff(noall)) {
gti.Depends.emplace_back(this->GetAllTargetName());
}
}
@@ -2666,7 +2664,7 @@ void cmGlobalGenerator::AddGlobalTarget_Install(
singleLine.push_back(cfgArg);
cfgArg = "-DEFFECTIVE_PLATFORM_NAME=$(EFFECTIVE_PLATFORM_NAME)";
} else {
cfgArg += mf->GetDefinition("CMAKE_CFG_INTDIR");
cfgArg += cmToCStr(mf->GetDefinition("CMAKE_CFG_INTDIR"));
}
singleLine.push_back(cfgArg);
}
@@ -3074,7 +3072,7 @@ void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target)
cmProp targetLabels = target->GetProperty("LABELS");
cmProp directoryLabels =
target->Target->GetMakefile()->GetProperty("LABELS");
const char* cmakeDirectoryLabels =
cmProp cmakeDirectoryLabels =
target->Target->GetMakefile()->GetDefinition("CMAKE_DIRECTORY_LABELS");
if (targetLabels || directoryLabels || cmakeDirectoryLabels) {
Json::Value lj_root(Json::objectValue);
@@ -3110,7 +3108,7 @@ void cmGlobalGenerator::WriteSummary(cmGeneratorTarget* target)
}
if (cmakeDirectoryLabels) {
cmExpandList(cmakeDirectoryLabels, cmakeDirectoryLabelsList);
cmExpandList(*cmakeDirectoryLabels, cmakeDirectoryLabelsList);
}
if (!directoryLabelsList.empty() || !cmakeDirectoryLabelsList.empty()) {
Source/cmGlobalGhsMultiGenerator.cxx
+7 -6
View File
@@ -100,13 +100,13 @@ bool cmGlobalGhsMultiGenerator::SetGeneratorToolset(std::string const& ts,
/* set the build tool to use */
std::string gbuild(tsp + ((tsp.back() == '/') ? "" : "/") +
DEFAULT_BUILD_PROGRAM);
const char* prevTool = mf->GetDefinition("CMAKE_MAKE_PROGRAM");
cmProp prevTool = mf->GetDefinition("CMAKE_MAKE_PROGRAM");
/* check if the toolset changed from last generate */
if (prevTool != nullptr && (gbuild != prevTool)) {
if (prevTool && (gbuild != *prevTool)) {
std::string message =
cmStrCat("toolset build tool: ", gbuild,
"\nDoes not match the previously used build tool: ", prevTool,
"\nDoes not match the previously used build tool: ", *prevTool,
"\nEither remove the CMakeCache.txt file and CMakeFiles "
"directory or choose a different binary directory.");
cmSystemTools::Error(message);
@@ -187,7 +187,8 @@ void cmGlobalGhsMultiGenerator::EnableLanguage(
mf->AddDefinition("GHSMULTI", "1"); // identifier for user CMake files
const char* tgtPlatform = mf->GetDefinition("GHS_TARGET_PLATFORM");
const char* tgtPlatform =
cmToCStrSafe(mf->GetDefinition("GHS_TARGET_PLATFORM"));
if (!tgtPlatform) {
cmSystemTools::Message("Green Hills MULTI: GHS_TARGET_PLATFORM not "
"specified; defaulting to \"integrity\"");
@@ -216,10 +217,10 @@ bool cmGlobalGhsMultiGenerator::FindMakeProgram(cmMakefile* /*mf*/)
void cmGlobalGhsMultiGenerator::GetToolset(cmMakefile* mf, std::string& tsd,
const std::string& ts)
{
const char* ghsRoot = mf->GetDefinition("GHS_TOOLSET_ROOT");
cmProp ghsRoot = mf->GetDefinition("GHS_TOOLSET_ROOT");
if (cmNonempty(ghsRoot)) {
tsd = ghsRoot;
tsd = *ghsRoot;
} else {
tsd = DEFAULT_TOOLSET_ROOT;
}
Source/cmGlobalNinjaGenerator.cxx
+3 -2
View File
@@ -32,6 +32,7 @@
#include "cmMessageType.h"
#include "cmNinjaLinkLineComputer.h"
#include "cmOutputConverter.h"
#include "cmProperty.h"
#include "cmRange.h"
#include "cmState.h"
#include "cmStateDirectory.h"
@@ -614,8 +615,8 @@ bool cmGlobalNinjaGenerator::FindMakeProgram(cmMakefile* mf)
if (!this->cmGlobalGenerator::FindMakeProgram(mf)) {
return false;
}
if (const char* ninjaCommand = mf->GetDefinition("CMAKE_MAKE_PROGRAM")) {
this->NinjaCommand = ninjaCommand;
if (cmProp ninjaCommand = mf->GetDefinition("CMAKE_MAKE_PROGRAM")) {
this->NinjaCommand = *ninjaCommand;
std::vector<std::string> command;
command.push_back(this->NinjaCommand);
command.emplace_back("--version");
Source/cmGlobalVisualStudio14Generator.cxx
+2 -2
View File
@@ -239,8 +239,8 @@ std::string cmGlobalVisualStudio14Generator::GetWindows10SDKMaxVersion(
{
// if the given value is set, it can either be OFF/FALSE or a valid SDK
// string
if (std::string const* value =
mf->GetDef("CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION_MAXIMUM")) {
if (cmProp value = mf->GetDefinition(
"CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION_MAXIMUM")) {
// If the value is some off/false value, then there is NO maximum set.
if (cmIsOff(value)) {
Source/cmGlobalVisualStudio7Generator.cxx
+2 -2
View File
@@ -676,11 +676,11 @@ std::set<std::string> cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild(
"CMAKE_VS_INCLUDE_" + t + "_TO_DEFAULT_BUILD";
// inspect CMAKE_VS_INCLUDE_<t>_TO_DEFAULT_BUILD properties
for (std::string const& i : configs) {
const char* propertyValue =
cmProp propertyValue =
target->Target->GetMakefile()->GetDefinition(propertyName);
if (propertyValue &&
cmIsOn(cmGeneratorExpression::Evaluate(
propertyValue, target->GetLocalGenerator(), i))) {
*propertyValue, target->GetLocalGenerator(), i))) {
activeConfigs.insert(i);
}
}
Source/cmGlobalXCodeGenerator.cxx
+13 -14
View File
@@ -3539,12 +3539,11 @@ bool cmGlobalXCodeGenerator::CreateXCodeObjects(
this->CreateString(defaultConfigName));
cmXCodeObject* buildSettings =
this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
const char* sysroot =
this->CurrentMakefile->GetDefinition("CMAKE_OSX_SYSROOT");
const char* deploymentTarget =
cmProp sysroot = this->CurrentMakefile->GetDefinition("CMAKE_OSX_SYSROOT");
cmProp deploymentTarget =
this->CurrentMakefile->GetDefinition("CMAKE_OSX_DEPLOYMENT_TARGET");
if (sysroot) {
buildSettings->AddAttribute("SDKROOT", this->CreateString(sysroot));
buildSettings->AddAttribute("SDKROOT", this->CreateString(*sysroot));
}
// recompute this as it may have been changed since enable language
this->ComputeArchitectures(this->CurrentMakefile);
@@ -3555,7 +3554,7 @@ bool cmGlobalXCodeGenerator::CreateXCodeObjects(
// When targeting macOS, use only the host architecture.
if (this->SystemName == "Darwin"_s &&
(!cmNonempty(sysroot) ||
cmSystemTools::LowerCase(sysroot).find("macos") !=
cmSystemTools::LowerCase(*sysroot).find("macos") !=
std::string::npos)) {
buildSettings->AddAttribute("ARCHS",
this->CreateString("$(NATIVE_ARCH_ACTUAL)"));
@@ -3566,7 +3565,7 @@ bool cmGlobalXCodeGenerator::CreateXCodeObjects(
}
if (cmNonempty(deploymentTarget)) {
buildSettings->AddAttribute(GetDeploymentPlatform(root->GetMakefile()),
this->CreateString(deploymentTarget));
this->CreateString(*deploymentTarget));
}
if (!this->GeneratorToolset.empty()) {
buildSettings->AddAttribute("GCC_VERSION",
@@ -3574,9 +3573,9 @@ bool cmGlobalXCodeGenerator::CreateXCodeObjects(
}
if (this->GetLanguageEnabled("Swift")) {
std::string swiftVersion;
if (const char* vers = this->CurrentMakefile->GetDefinition(
if (cmProp vers = this->CurrentMakefile->GetDefinition(
"CMAKE_Swift_LANGUAGE_VERSION")) {
swiftVersion = vers;
swiftVersion = *vers;
} else if (this->XcodeVersion >= 102) {
swiftVersion = "4.0";
} else if (this->XcodeVersion >= 83) {
@@ -3659,7 +3658,7 @@ std::string cmGlobalXCodeGenerator::GetObjectsDirectory(
void cmGlobalXCodeGenerator::ComputeArchitectures(cmMakefile* mf)
{
this->Architectures.clear();
const char* sysroot = mf->GetDefinition("CMAKE_OSX_SYSROOT");
cmProp sysroot = mf->GetDefinition("CMAKE_OSX_SYSROOT");
if (sysroot) {
mf->GetDefExpandList("CMAKE_OSX_ARCHITECTURES", this->Architectures);
}
@@ -3668,8 +3667,8 @@ void cmGlobalXCodeGenerator::ComputeArchitectures(cmMakefile* mf)
// With no ARCHS we use ONLY_ACTIVE_ARCH and possibly a
// platform-specific default ARCHS placeholder value.
// Look up the arch that Xcode chooses in this case.
if (const char* arch = mf->GetDefinition("CMAKE_XCODE_ARCHS")) {
this->ObjectDirArchDefault = arch;
if (cmProp arch = mf->GetDefinition("CMAKE_XCODE_ARCHS")) {
this->ObjectDirArchDefault = *arch;
// We expect only one arch but choose the first just in case.
std::string::size_type pos = this->ObjectDirArchDefault.find(';');
if (pos != std::string::npos) {
@@ -4035,9 +4034,9 @@ std::string cmGlobalXCodeGenerator::LookupFlags(
{
if (!varNameLang.empty()) {
std::string varName = cmStrCat(varNamePrefix, varNameLang, varNameSuffix);
if (const char* varValue = this->CurrentMakefile->GetDefinition(varName)) {
if (*varValue) {
return varValue;
if (cmProp varValue = this->CurrentMakefile->GetDefinition(varName)) {
if (!varValue->empty()) {
return *varValue;
}
}
}
Source/cmGraphVizWriter.cxx
+5 -4
View File
@@ -17,6 +17,7 @@
#include "cmLinkItem.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmState.h"
#include "cmStateSnapshot.h"
#include "cmStringAlgorithms.h"
@@ -229,9 +230,9 @@ void cmGraphVizWriter::ReadSettings(
#define __set_if_set(var, cmakeDefinition) \
do { \
const char* value = mf.GetDefinition(cmakeDefinition); \
cmProp value = mf.GetDefinition(cmakeDefinition); \
if (value) { \
(var) = value; \
(var) = *value; \
} \
} while (false)
@@ -241,9 +242,9 @@ void cmGraphVizWriter::ReadSettings(
#define __set_bool_if_set(var, cmakeDefinition) \
do { \
const char* value = mf.GetDefinition(cmakeDefinition); \
cmProp value = mf.GetDefinition(cmakeDefinition); \
if (value) { \
(var) = cmIsOn(value); \
(var) = cmIsOn(*value); \
} \
} while (false)
Source/cmIncludeGuardCommand.cxx
+1 -1
View File
@@ -75,7 +75,7 @@ bool cmIncludeGuardCommand(std::vector<std::string> const& args,
}
std::string includeGuardVar = GetIncludeGuardVariableName(
status.GetMakefile().GetDefinition("CMAKE_CURRENT_LIST_FILE"));
*status.GetMakefile().GetDefinition("CMAKE_CURRENT_LIST_FILE"));
cmMakefile* const mf = &status.GetMakefile();
Source/cmInstallTargetGenerator.cxx
+3 -3
View File
@@ -820,7 +820,7 @@ void cmInstallTargetGenerator::AddStripRule(std::ostream& os, Indent indent,
os << indent << "if(CMAKE_INSTALL_DO_STRIP)\n";
os << indent << " execute_process(COMMAND \""
<< this->Target->Target->GetMakefile()->GetDefinition("CMAKE_STRIP")
<< this->Target->Target->GetMakefile()->GetSafeDefinition("CMAKE_STRIP")
<< "\" " << stripArgs << "\"" << toDestDirPath << "\")\n";
os << indent << "endif()\n";
}
@@ -858,9 +858,9 @@ void cmInstallTargetGenerator::AddUniversalInstallRule(
return;
}
const char* xcodeVersion = mf->GetDefinition("XCODE_VERSION");
cmProp xcodeVersion = mf->GetDefinition("XCODE_VERSION");
if (!xcodeVersion ||
cmSystemTools::VersionCompareGreater("6", xcodeVersion)) {
cmSystemTools::VersionCompareGreater("6", *xcodeVersion)) {
return;
}
Source/cmJsonObjects.cxx
+2 -2
View File
@@ -631,8 +631,8 @@ static Json::Value DumpProjectList(const cmake* cm, std::string const& config)
// Project structure information:
const cmMakefile* mf = lg->GetMakefile();
auto minVersion = mf->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION");
pObj[kMINIMUM_CMAKE_VERSION] = minVersion ? minVersion : "";
auto minVersion = mf->GetSafeDefinition("CMAKE_MINIMUM_REQUIRED_VERSION");
pObj[kMINIMUM_CMAKE_VERSION] = minVersion;
pObj[kSOURCE_DIRECTORY_KEY] = mf->GetCurrentSourceDirectory();
pObj[kBUILD_DIRECTORY_KEY] = mf->GetCurrentBinaryDirectory();
pObj[kTARGETS_KEY] = DumpTargetsList(projectIt.second, config);
Source/cmListCommand.cxx
+3 -2
View File
@@ -27,6 +27,7 @@
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmPolicies.h"
#include "cmProperty.h"
#include "cmRange.h"
#include "cmStringAlgorithms.h"
#include "cmStringReplaceHelper.h"
@@ -44,11 +45,11 @@ bool GetListString(std::string& listString, const std::string& var,
const cmMakefile& makefile)
{
// get the old value
const char* cacheValue = makefile.GetDefinition(var);
cmProp cacheValue = makefile.GetDefinition(var);
if (!cacheValue) {
return false;
}
listString = cacheValue;
listString = *cacheValue;
return true;
}
Source/cmLocalCommonGenerator.cxx
+3 -2
View File
@@ -8,6 +8,7 @@
#include "cmGeneratorTarget.h"
#include "cmMakefile.h"
#include "cmOutputConverter.h"
#include "cmProperty.h"
#include "cmStringAlgorithms.h"
class cmGlobalGenerator;
@@ -62,13 +63,13 @@ std::string cmLocalCommonGenerator::GetTargetFortranFlags(
// If there is a separate module path flag then duplicate the
// include path with it. This compiler does not search the include
// path for modules.
if (const char* modpath_flag =
if (cmProp modpath_flag =
this->Makefile->GetDefinition("CMAKE_Fortran_MODPATH_FLAG")) {
std::vector<std::string> includes;
this->GetIncludeDirectories(includes, target, "C", config);
for (std::string const& id : includes) {
std::string flg =
cmStrCat(modpath_flag,
cmStrCat(*modpath_flag,
this->ConvertToOutputFormat(id, cmOutputConverter::SHELL));
this->AppendFlags(flags, flg);
}
Source/cmLocalGenerator.cxx
+91 -91
View File
@@ -116,22 +116,22 @@ cmLocalGenerator::cmLocalGenerator(cmGlobalGenerator* gg, cmMakefile* makefile)
std::vector<std::string> enabledLanguages =
this->GetState()->GetEnabledLanguages();
if (const char* sysrootCompile =
if (cmProp sysrootCompile =
this->Makefile->GetDefinition("CMAKE_SYSROOT_COMPILE")) {
this->CompilerSysroot = sysrootCompile;
this->CompilerSysroot = *sysrootCompile;
} else {
this->CompilerSysroot = this->Makefile->GetSafeDefinition("CMAKE_SYSROOT");
}
if (const char* sysrootLink =
if (cmProp sysrootLink =
this->Makefile->GetDefinition("CMAKE_SYSROOT_LINK")) {
this->LinkerSysroot = sysrootLink;
this->LinkerSysroot = *sysrootLink;
} else {
this->LinkerSysroot = this->Makefile->GetSafeDefinition("CMAKE_SYSROOT");
}
if (cmProp appleArchSysroots =
this->Makefile->GetDef("CMAKE_APPLE_ARCH_SYSROOTS")) {
this->Makefile->GetDefinition("CMAKE_APPLE_ARCH_SYSROOTS")) {
std::string const& appleArchs =
this->Makefile->GetSafeDefinition("CMAKE_OSX_ARCHITECTURES");
std::vector<std::string> archs;
@@ -220,10 +220,10 @@ void cmLocalGenerator::ComputeObjectMaxPath()
#else
this->ObjectPathMax = 1000;
#endif
const char* plen = this->Makefile->GetDefinition("CMAKE_OBJECT_PATH_MAX");
cmProp plen = this->Makefile->GetDefinition("CMAKE_OBJECT_PATH_MAX");
if (cmNonempty(plen)) {
unsigned int pmax;
if (sscanf(plen, "%u", &pmax) == 1) {
if (sscanf(plen->c_str(), "%u", &pmax) == 1) {
if (pmax >= 128) {
this->ObjectPathMax = pmax;
} else {
@@ -235,7 +235,7 @@ void cmLocalGenerator::ComputeObjectMaxPath()
}
} else {
std::ostringstream w;
w << "CMAKE_OBJECT_PATH_MAX is set to \"" << plen
w << "CMAKE_OBJECT_PATH_MAX is set to \"" << *plen
<< "\", which fails to parse as a positive integer. "
<< "The value will be ignored.";
this->IssueMessage(MessageType::AUTHOR_WARNING, w.str());
@@ -358,7 +358,7 @@ void cmLocalGenerator::GenerateTestFiles()
}
// Add directory labels property
const char* directoryLabels =
cmProp directoryLabels =
this->Makefile->GetDefinition("CMAKE_DIRECTORY_LABELS");
cmProp labels = this->Makefile->GetProperty("LABELS");
@@ -371,7 +371,7 @@ void cmLocalGenerator::GenerateTestFiles()
fout << ";";
}
if (directoryLabels) {
fout << cmOutputConverter::EscapeForCMake(directoryLabels);
fout << cmOutputConverter::EscapeForCMake(*directoryLabels);
}
fout << ")\n";
}
@@ -425,7 +425,8 @@ void cmLocalGenerator::ProcessEvaluationFiles(
void cmLocalGenerator::GenerateInstallRules()
{
// Compute the install prefix.
const char* prefix = this->Makefile->GetDefinition("CMAKE_INSTALL_PREFIX");
const char* prefix =
cmToCStr(this->Makefile->GetDefinition("CMAKE_INSTALL_PREFIX"));
#if defined(_WIN32) && !defined(__CYGWIN__)
std::string prefix_win32;
@@ -433,10 +434,10 @@ void cmLocalGenerator::GenerateInstallRules()
if (!cmSystemTools::GetEnv("SystemDrive", prefix_win32)) {
prefix_win32 = "C:";
}
const char* project_name = this->Makefile->GetDefinition("PROJECT_NAME");
cmProp project_name = this->Makefile->GetDefinition("PROJECT_NAME");
if (cmNonempty(project_name)) {
prefix_win32 += "/Program Files/";
prefix_win32 += project_name;
prefix_win32 += *project_name;
} else {
prefix_win32 += "/InstalledCMakeProject";
}
@@ -457,9 +458,9 @@ void cmLocalGenerator::GenerateInstallRules()
prefix = "/usr/local";
}
#endif
if (const char* stagingPrefix =
if (cmProp stagingPrefix =
this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX")) {
prefix = stagingPrefix;
prefix = stagingPrefix->c_str();
}
// Compute the set of configurations.
@@ -539,40 +540,40 @@ void cmLocalGenerator::GenerateInstallRules()
/* clang-format on */
// Copy user-specified install options to the install code.
if (const char* so_no_exe =
if (cmProp so_no_exe =
this->Makefile->GetDefinition("CMAKE_INSTALL_SO_NO_EXE")) {
/* clang-format off */
fout <<
"# Install shared libraries without execute permission?\n"
"if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)\n"
" set(CMAKE_INSTALL_SO_NO_EXE \"" << so_no_exe << "\")\n"
" set(CMAKE_INSTALL_SO_NO_EXE \"" << *so_no_exe << "\")\n"
"endif()\n"
"\n";
/* clang-format on */
}
// Copy cmake cross compile state to install code.
if (const char* crosscompiling =
if (cmProp crosscompiling =
this->Makefile->GetDefinition("CMAKE_CROSSCOMPILING")) {
/* clang-format off */
fout <<
"# Is this installation the result of a crosscompile?\n"
"if(NOT DEFINED CMAKE_CROSSCOMPILING)\n"
" set(CMAKE_CROSSCOMPILING \"" << crosscompiling << "\")\n"
" set(CMAKE_CROSSCOMPILING \"" << *crosscompiling << "\")\n"
"endif()\n"
"\n";
/* clang-format on */
}
// Write default directory permissions.
if (const char* defaultDirPermissions = this->Makefile->GetDefinition(
if (cmProp defaultDirPermissions = this->Makefile->GetDefinition(
"CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS")) {
/* clang-format off */
fout <<
"# Set default install directory permissions.\n"
"if(NOT DEFINED CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS)\n"
" set(CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS \""
<< defaultDirPermissions << "\")\n"
<< *defaultDirPermissions << "\")\n"
"endif()\n"
"\n";
/* clang-format on */
@@ -581,14 +582,14 @@ void cmLocalGenerator::GenerateInstallRules()
// Write out CMAKE_GET_RUNTIME_DEPENDENCIES_PLATFORM so that
// installed code that uses `file(GET_RUNTIME_DEPENDENCIES)`
// has same platform variable as when running cmake
if (const char* platform = this->Makefile->GetDefinition(
if (cmProp platform = this->Makefile->GetDefinition(
"CMAKE_GET_RUNTIME_DEPENDENCIES_PLATFORM")) {
/* clang-format off */
fout <<
"# Set default install directory permissions.\n"
"if(NOT DEFINED CMAKE_GET_RUNTIME_DEPENDENCIES_PLATFORM)\n"
" set(CMAKE_GET_RUNTIME_DEPENDENCIES_PLATFORM \""
<< platform << "\")\n"
<< *platform << "\")\n"
"endif()\n"
"\n";
/* clang-format on */
@@ -597,14 +598,14 @@ void cmLocalGenerator::GenerateInstallRules()
// Write out CMAKE_GET_RUNTIME_DEPENDENCIES_TOOL so that
// installed code that uses `file(GET_RUNTIME_DEPENDENCIES)`
// has same tool selected as when running cmake
if (const char* command =
if (cmProp command =
this->Makefile->GetDefinition("CMAKE_GET_RUNTIME_DEPENDENCIES_TOOL")) {
/* clang-format off */
fout <<
"# Set default install directory permissions.\n"
"if(NOT DEFINED CMAKE_GET_RUNTIME_DEPENDENCIES_TOOL)\n"
" set(CMAKE_GET_RUNTIME_DEPENDENCIES_TOOL \""
<< command << "\")\n"
<< *command << "\")\n"
"endif()\n"
"\n";
/* clang-format on */
@@ -613,14 +614,14 @@ void cmLocalGenerator::GenerateInstallRules()
// Write out CMAKE_GET_RUNTIME_DEPENDENCIES_COMMAND so that
// installed code that uses `file(GET_RUNTIME_DEPENDENCIES)`
// has same path to the tool as when running cmake
if (const char* command = this->Makefile->GetDefinition(
if (cmProp command = this->Makefile->GetDefinition(
"CMAKE_GET_RUNTIME_DEPENDENCIES_COMMAND")) {
/* clang-format off */
fout <<
"# Set default install directory permissions.\n"
"if(NOT DEFINED CMAKE_GET_RUNTIME_DEPENDENCIES_COMMAND)\n"
" set(CMAKE_GET_RUNTIME_DEPENDENCIES_COMMAND \""
<< command << "\")\n"
<< *command << "\")\n"
"endif()\n"
"\n";
/* clang-format on */
@@ -631,13 +632,13 @@ void cmLocalGenerator::GenerateInstallRules()
// CMAKE_GET_RUNTIME_DEPENDENCIES_COMMAND has consistent
// logic to fallback to CMAKE_OBJDUMP when `objdump` is
// not on the path
if (const char* command = this->Makefile->GetDefinition("CMAKE_OBJDUMP")) {
if (cmProp command = this->Makefile->GetDefinition("CMAKE_OBJDUMP")) {
/* clang-format off */
fout <<
"# Set default install directory permissions.\n"
"if(NOT DEFINED CMAKE_OBJDUMP)\n"
" set(CMAKE_OBJDUMP \""
<< command << "\")\n"
<< *command << "\")\n"
"endif()\n"
"\n";
/* clang-format on */
@@ -858,8 +859,8 @@ std::string cmLocalGenerator::GetIncludeFlags(
std::string const& includeFlag =
this->Makefile->GetSafeDefinition(cmStrCat("CMAKE_INCLUDE_FLAG_", lang));
const char* sep =
this->Makefile->GetDefinition(cmStrCat("CMAKE_INCLUDE_FLAG_SEP_", lang));
const char* sep = cmToCStr(
this->Makefile->GetDefinition(cmStrCat("CMAKE_INCLUDE_FLAG_SEP_", lang)));
bool quotePaths = false;
if (this->Makefile->GetDefinition("CMAKE_QUOTE_INCLUDE_PATHS")) {
quotePaths = true;
@@ -876,15 +877,15 @@ std::string cmLocalGenerator::GetIncludeFlags(
// Support special system include flag if it is available and the
// normal flag is repeated for each directory.
const char* sysIncludeFlag = nullptr;
cmProp sysIncludeFlag = nullptr;
if (repeatFlag) {
sysIncludeFlag = this->Makefile->GetDefinition(
cmStrCat("CMAKE_INCLUDE_SYSTEM_FLAG_", lang));
}
const char* fwSearchFlag = this->Makefile->GetDefinition(
cmProp fwSearchFlag = this->Makefile->GetDefinition(
cmStrCat("CMAKE_", lang, "_FRAMEWORK_SEARCH_FLAG"));
const char* sysFwSearchFlag = this->Makefile->GetDefinition(
cmProp sysFwSearchFlag = this->Makefile->GetDefinition(
cmStrCat("CMAKE_", lang, "_SYSTEM_FRAMEWORK_SEARCH_FLAG"));
bool flagUsed = false;
@@ -900,9 +901,9 @@ std::string cmLocalGenerator::GetIncludeFlags(
if (emitted.insert(frameworkDir).second) {
if (sysFwSearchFlag && target &&
target->IsSystemIncludeDirectory(i, config, lang)) {
includeFlags << sysFwSearchFlag;
includeFlags << *sysFwSearchFlag;
} else {
includeFlags << fwSearchFlag;
includeFlags << *fwSearchFlag;
}
includeFlags << this->ConvertToOutputFormat(frameworkDir, shellFormat)
<< " ";
@@ -913,7 +914,7 @@ std::string cmLocalGenerator::GetIncludeFlags(
if (!flagUsed || repeatFlag) {
if (sysIncludeFlag && target &&
target->IsSystemIncludeDirectory(i, config, lang)) {
includeFlags << sysIncludeFlag;
includeFlags << *sysIncludeFlag;
} else {
includeFlags << includeFlag;
}
@@ -953,9 +954,9 @@ void cmLocalGenerator::AddCompileOptions(std::vector<BT<std::string>>& flags,
const std::string& lang,
const std::string& config)
{
std::string langFlagRegexVar = std::string("CMAKE_") + lang + "_FLAG_REGEX";
std::string langFlagRegexVar = cmStrCat("CMAKE_", lang, "_FLAG_REGEX");
if (const char* langFlagRegexStr =
if (cmProp langFlagRegexStr =
this->Makefile->GetDefinition(langFlagRegexVar)) {
// Filter flags acceptable to this language.
if (cmProp targetFlags = target->GetProperty("COMPILE_FLAGS")) {
@@ -964,7 +965,7 @@ void cmLocalGenerator::AddCompileOptions(std::vector<BT<std::string>>& flags,
// Re-escape these flags since COMPILE_FLAGS were already parsed
// as a command line above.
std::string compileOpts;
this->AppendCompileOptions(compileOpts, opts, langFlagRegexStr);
this->AppendCompileOptions(compileOpts, opts, langFlagRegexStr->c_str());
if (!compileOpts.empty()) {
flags.emplace_back(std::move(compileOpts));
}
@@ -972,7 +973,8 @@ void cmLocalGenerator::AddCompileOptions(std::vector<BT<std::string>>& flags,
std::vector<BT<std::string>> targetCompileOpts =
target->GetCompileOptions(config, lang);
// COMPILE_OPTIONS are escaped.
this->AppendCompileOptions(flags, targetCompileOpts, langFlagRegexStr);
this->AppendCompileOptions(flags, targetCompileOpts,
langFlagRegexStr->c_str());
} else {
// Use all flags.
if (cmProp targetFlags = target->GetProperty("COMPILE_FLAGS")) {
@@ -1022,7 +1024,7 @@ void cmLocalGenerator::AddCompileOptions(std::vector<BT<std::string>>& flags,
// Add compile flag for the MSVC compiler only.
cmMakefile* mf = this->GetMakefile();
if (const char* jmc =
if (cmProp jmc =
mf->GetDefinition("CMAKE_" + lang + "_COMPILE_OPTIONS_JMC")) {
// Handle Just My Code debugging flags, /JMC.
@@ -1036,7 +1038,7 @@ void cmLocalGenerator::AddCompileOptions(std::vector<BT<std::string>>& flags,
std::string isJMCEnabled =
cmGeneratorExpression::Evaluate(*jmcExprGen, this, config);
if (cmIsOn(isJMCEnabled)) {
std::vector<std::string> optVec = cmExpandedList(jmc);
std::vector<std::string> optVec = cmExpandedList(*jmc);
std::string jmcFlags;
this->AppendCompileOptions(jmcFlags, optVec);
if (!jmcFlags.empty()) {
@@ -1652,7 +1654,7 @@ static std::string GetFrameworkFlags(const std::string& lang,
}
std::string fwSearchFlagVar = "CMAKE_" + lang + "_FRAMEWORK_SEARCH_FLAG";
const char* fwSearchFlag = mf->GetDefinition(fwSearchFlagVar);
cmProp fwSearchFlag = mf->GetDefinition(fwSearchFlagVar);
if (!cmNonempty(fwSearchFlag)) {
return std::string();
}
@@ -1679,7 +1681,7 @@ static std::string GetFrameworkFlags(const std::string& lang,
std::vector<std::string> const& frameworks = cli->GetFrameworkPaths();
for (std::string const& framework : frameworks) {
if (emitted.insert(framework).second) {
flags += fwSearchFlag;
flags += *fwSearchFlag;
flags +=
lg->ConvertToOutputFormat(framework, cmOutputConverter::SHELL);
flags += " ";
@@ -1761,18 +1763,18 @@ void cmLocalGenerator::OutputLinkLibraries(
std::string linkLanguage = cli.GetLinkLanguage();
std::string libPathFlag;
if (const char* value = this->Makefile->GetDefinition(
if (cmProp value = this->Makefile->GetDefinition(
"CMAKE_" + cli.GetLinkLanguage() + "_LIBRARY_PATH_FLAG")) {
libPathFlag = value;
libPathFlag = *value;
} else {
libPathFlag =
this->Makefile->GetRequiredDefinition("CMAKE_LIBRARY_PATH_FLAG");
}
std::string libPathTerminator;
if (const char* value = this->Makefile->GetDefinition(
if (cmProp value = this->Makefile->GetDefinition(
"CMAKE_" + cli.GetLinkLanguage() + "_LIBRARY_PATH_TERMINATOR")) {
libPathTerminator = value;
libPathTerminator = *value;
} else {
libPathTerminator =
this->Makefile->GetRequiredDefinition("CMAKE_LIBRARY_PATH_TERMINATOR");
@@ -1886,16 +1888,15 @@ void cmLocalGenerator::AddArchitectureFlags(std::string& flags,
}
}
const char* sysroot = this->Makefile->GetDefinition("CMAKE_OSX_SYSROOT");
if (sysroot && sysroot[0] == '/' && !sysroot[1]) {
cmProp sysroot = this->Makefile->GetDefinition("CMAKE_OSX_SYSROOT");
if (sysroot && *sysroot == "/") {
sysroot = nullptr;
}
std::string sysrootFlagVar =
std::string("CMAKE_") + lang + "_SYSROOT_FLAG";
const char* sysrootFlag = this->Makefile->GetDefinition(sysrootFlagVar);
std::string sysrootFlagVar = "CMAKE_" + lang + "_SYSROOT_FLAG";
cmProp sysrootFlag = this->Makefile->GetDefinition(sysrootFlagVar);
if (cmNonempty(sysrootFlag)) {
if (!this->AppleArchSysroots.empty() &&
!this->AllAppleArchSysrootsAreTheSame(archs, sysroot)) {
!this->AllAppleArchSysrootsAreTheSame(archs, cmToCStr(sysroot))) {
for (std::string const& arch : archs) {
std::string const& archSysroot = this->AppleArchSysroots[arch];
if (cmIsOff(archSysroot)) {
@@ -1904,28 +1905,28 @@ void cmLocalGenerator::AddArchitectureFlags(std::string& flags,
if (filterArch.empty() || filterArch == arch) {
flags += " -Xarch_" + arch + " ";
// Combine sysroot flag and path to work with -Xarch
std::string arch_sysroot = sysrootFlag + archSysroot;
std::string arch_sysroot = *sysrootFlag + archSysroot;
flags += this->ConvertToOutputFormat(arch_sysroot, SHELL);
}
}
} else if (sysroot && *sysroot) {
} else if (cmNonempty(sysroot)) {
flags += " ";
flags += sysrootFlag;
flags += *sysrootFlag;
flags += " ";
flags += this->ConvertToOutputFormat(sysroot, SHELL);
flags += this->ConvertToOutputFormat(*sysroot, SHELL);
}
}
const char* deploymentTarget =
cmProp deploymentTarget =
this->Makefile->GetDefinition("CMAKE_OSX_DEPLOYMENT_TARGET");
std::string deploymentTargetFlagVar =
std::string("CMAKE_") + lang + "_OSX_DEPLOYMENT_TARGET_FLAG";
const char* deploymentTargetFlag =
"CMAKE_" + lang + "_OSX_DEPLOYMENT_TARGET_FLAG";
cmProp deploymentTargetFlag =
this->Makefile->GetDefinition(deploymentTargetFlagVar);
if (cmNonempty(deploymentTargetFlag) && cmNonempty(deploymentTarget)) {
flags += " ";
flags += deploymentTargetFlag;
flags += deploymentTarget;
flags += *deploymentTargetFlag;
flags += *deploymentTarget;
}
}
}
@@ -1944,10 +1945,10 @@ void cmLocalGenerator::AddLanguageFlags(std::string& flags,
if (lang == "Swift") {
if (cmProp v = target->GetProperty("Swift_LANGUAGE_VERSION")) {
if (cmSystemTools::VersionCompare(
cmSystemTools::OP_GREATER_EQUAL,
this->Makefile->GetDefinition("CMAKE_Swift_COMPILER_VERSION"),
"4.2")) {
if (cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER_EQUAL,
cmToCStr(this->Makefile->GetDefinition(
"CMAKE_Swift_COMPILER_VERSION")),
"4.2")) {
this->AppendFlags(flags, "-swift-version " + *v);
}
}
@@ -1968,7 +1969,7 @@ void cmLocalGenerator::AddLanguageFlags(std::string& flags,
}
// Add VFS Overlay for Clang compiliers
if (compiler == "Clang") {
if (const char* vfsOverlay =
if (cmProp vfsOverlay =
this->Makefile->GetDefinition("CMAKE_CLANG_VFS_OVERLAY")) {
std::string const& compilerSimulateId =
this->Makefile->GetSafeDefinition(
@@ -1977,17 +1978,17 @@ void cmLocalGenerator::AddLanguageFlags(std::string& flags,
this->AppendCompileOptions(
flags,
std::vector<std::string>{ "-Xclang", "-ivfsoverlay", "-Xclang",
vfsOverlay });
*vfsOverlay });
} else {
this->AppendCompileOptions(
flags, std::vector<std::string>{ "-ivfsoverlay", vfsOverlay });
flags, std::vector<std::string>{ "-ivfsoverlay", *vfsOverlay });
}
}
}
// Add MSVC runtime library flags. This is activated by the presence
// of a default selection whether or not it is overridden by a property.
cmProp msvcRuntimeLibraryDefault =
this->Makefile->GetDef("CMAKE_MSVC_RUNTIME_LIBRARY_DEFAULT");
this->Makefile->GetDefinition("CMAKE_MSVC_RUNTIME_LIBRARY_DEFAULT");
if (cmNonempty(msvcRuntimeLibraryDefault)) {
cmProp msvcRuntimeLibraryValue =
target->GetProperty("MSVC_RUNTIME_LIBRARY");
@@ -1997,11 +1998,10 @@ void cmLocalGenerator::AddLanguageFlags(std::string& flags,
std::string const msvcRuntimeLibrary = cmGeneratorExpression::Evaluate(
*msvcRuntimeLibraryValue, this, config, target);
if (!msvcRuntimeLibrary.empty()) {
if (const char* msvcRuntimeLibraryOptions =
this->Makefile->GetDefinition(
"CMAKE_" + lang + "_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_" +
msvcRuntimeLibrary)) {
this->AppendCompileOptions(flags, msvcRuntimeLibraryOptions);
if (cmProp msvcRuntimeLibraryOptions = this->Makefile->GetDefinition(
"CMAKE_" + lang + "_COMPILE_OPTIONS_MSVC_RUNTIME_LIBRARY_" +
msvcRuntimeLibrary)) {
this->AppendCompileOptions(flags, *msvcRuntimeLibraryOptions);
} else if ((this->Makefile->GetSafeDefinition(
"CMAKE_" + lang + "_COMPILER_ID") == "MSVC" ||
this->Makefile->GetSafeDefinition(
@@ -2178,9 +2178,9 @@ void cmLocalGenerator::AddCompilerRequirementFlag(
std::string const& optionFlagDef =
standardResolver.GetCompileOptionDef(target, lang, config);
if (!optionFlagDef.empty()) {
auto opt = target->Target->GetMakefile()->GetDefinition(optionFlagDef);
cmProp opt = target->Target->GetMakefile()->GetDefinition(optionFlagDef);
if (opt) {
std::vector<std::string> optVec = cmExpandedList(opt);
std::vector<std::string> optVec = cmExpandedList(*opt);
for (std::string const& i : optVec) {
this->AppendFlagEscape(flags, i);
}
@@ -2195,7 +2195,7 @@ static void AddVisibilityCompileOption(std::string& flags,
std::string* warnCMP0063)
{
std::string compileOption = "CMAKE_" + lang + "_COMPILE_OPTIONS_VISIBILITY";
const char* opt = lg->GetMakefile()->GetDefinition(compileOption);
cmProp opt = lg->GetMakefile()->GetDefinition(compileOption);
if (!opt) {
return;
}
@@ -2219,7 +2219,7 @@ static void AddVisibilityCompileOption(std::string& flags,
cmSystemTools::Error(e.str());
return;
}
std::string option = opt + *prop;
std::string option = *opt + *prop;
lg->AppendFlags(flags, option);
}
@@ -2231,7 +2231,7 @@ static void AddInlineVisibilityCompileOption(std::string& flags,
{
std::string compileOption =
cmStrCat("CMAKE_", lang, "_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN");
const char* opt = lg->GetMakefile()->GetDefinition(compileOption);
cmProp opt = lg->GetMakefile()->GetDefinition(compileOption);
if (!opt) {
return;
}
@@ -2244,7 +2244,7 @@ static void AddInlineVisibilityCompileOption(std::string& flags,
*warnCMP0063 += " VISIBILITY_INLINES_HIDDEN\n";
return;
}
lg->AppendFlags(flags, opt);
lg->AppendFlags(flags, *opt);
}
void cmLocalGenerator::AddVisibilityPresetFlags(
@@ -2917,12 +2917,12 @@ void cmLocalGenerator::AppendIPOLinkerFlags(std::string& flags,
}
const std::string name = "CMAKE_" + lang + "_LINK_OPTIONS_IPO";
const char* rawFlagsList = this->Makefile->GetDefinition(name);
cmProp rawFlagsList = this->Makefile->GetDefinition(name);
if (rawFlagsList == nullptr) {
return;
}
std::vector<std::string> flagsList = cmExpandedList(rawFlagsList);
std::vector<std::string> flagsList = cmExpandedList(*rawFlagsList);
for (std::string const& o : flagsList) {
this->AppendFlagEscape(flags, o);
}
@@ -3108,10 +3108,10 @@ void cmLocalGenerator::JoinDefines(const std::set<std::string>& defines,
// Lookup the define flag for the current language.
std::string dflag = "-D";
if (!lang.empty()) {
const char* df =
cmProp df =
this->Makefile->GetDefinition(cmStrCat("CMAKE_", lang, "_DEFINE_FLAG"));
if (cmNonempty(df)) {
dflag = df;
dflag = *df;
}
}
const char* itemSeparator = definesString.empty() ? "" : " ";
@@ -3155,10 +3155,10 @@ void cmLocalGenerator::AppendFeatureOptions(std::string& flags,
const std::string& lang,
const char* feature)
{
const char* optionList = this->Makefile->GetDefinition(
cmProp optionList = this->Makefile->GetDefinition(
cmStrCat("CMAKE_", lang, "_COMPILE_OPTIONS_", feature));
if (optionList != nullptr) {
std::vector<std::string> options = cmExpandedList(optionList);
std::vector<std::string> options = cmExpandedList(*optionList);
for (std::string const& o : options) {
this->AppendFlagEscape(flags, o);
}
@@ -3613,9 +3613,9 @@ KWIML_INT_uint64_t cmLocalGenerator::GetBackwardsCompatibility()
unsigned int major = 0;
unsigned int minor = 0;
unsigned int patch = 0;
if (const char* value =
if (cmProp value =
this->Makefile->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY")) {
switch (sscanf(value, "%u.%u.%u", &major, &minor, &patch)) {
switch (sscanf(value->c_str(), "%u.%u.%u", &major, &minor, &patch)) {
case 2:
patch = 0;
break;
Source/cmLocalNinjaGenerator.cxx
+3 -2
View File
@@ -312,7 +312,7 @@ void cmLocalNinjaGenerator::WritePools(std::ostream& os)
cmProp jobpools =
this->GetCMakeInstance()->GetState()->GetGlobalProperty("JOB_POOLS");
if (!jobpools) {
jobpools = this->GetMakefile()->GetDef("CMAKE_JOB_POOLS");
jobpools = this->GetMakefile()->GetDefinition("CMAKE_JOB_POOLS");
}
if (jobpools) {
cmGlobalNinjaGenerator::WriteComment(
@@ -363,7 +363,8 @@ void cmLocalNinjaGenerator::WriteProcessedMakefile(std::ostream& os)
{
cmGlobalNinjaGenerator::WriteDivider(os);
os << "# Write statements declared in CMakeLists.txt:\n"
<< "# " << this->Makefile->GetDefinition("CMAKE_CURRENT_LIST_FILE")
<< "# "
<< cmToCStr(this->Makefile->GetDefinition("CMAKE_CURRENT_LIST_FILE"))
<< '\n';
if (this->IsRootMakefile()) {
os << "# Which is the root file.\n";
Source/cmLocalUnixMakefileGenerator3.cxx
+17 -18
View File
@@ -519,9 +519,9 @@ void cmLocalUnixMakefileGenerator3::WriteMakeRule(
// Mark the rule as symbolic if requested.
if (symbolic) {
if (const char* sym =
if (cmProp sym =
this->Makefile->GetDefinition("CMAKE_MAKE_SYMBOLIC_RULE")) {
os << tgt << space << ": " << sym << "\n";
os << tgt << space << ": " << *sym << "\n";
}
}
@@ -833,9 +833,8 @@ void cmLocalUnixMakefileGenerator3::AppendRuleDepend(
{
// Add a dependency on the rule file itself unless an option to skip
// it is specifically enabled by the user or project.
const char* nodep =
this->Makefile->GetDefinition("CMAKE_SKIP_RULE_DEPENDENCY");
if (!nodep || cmIsOff(nodep)) {
cmProp nodep = this->Makefile->GetDefinition("CMAKE_SKIP_RULE_DEPENDENCY");
if (cmIsOff(nodep)) {
depends.emplace_back(ruleFileName);
}
}
@@ -1395,22 +1394,22 @@ bool cmLocalUnixMakefileGenerator3::ScanDependencies(
// Lookup useful directory information.
if (haveDirectoryInfo) {
// Test whether we need to force Unix paths.
if (const char* force = mf->GetDefinition("CMAKE_FORCE_UNIX_PATHS")) {
if (cmProp force = mf->GetDefinition("CMAKE_FORCE_UNIX_PATHS")) {
if (!cmIsOff(force)) {
cmSystemTools::SetForceUnixPaths(true);
}
}
// Setup relative path top directories.
if (const char* relativePathTopSource =
if (cmProp relativePathTopSource =
mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_SOURCE")) {
this->StateSnapshot.GetDirectory().SetRelativePathTopSource(
relativePathTopSource);
relativePathTopSource->c_str());
}
if (const char* relativePathTopBinary =
if (cmProp relativePathTopBinary =
mf->GetDefinition("CMAKE_RELATIVE_PATH_TOP_BINARY")) {
this->StateSnapshot.GetDirectory().SetRelativePathTopBinary(
relativePathTopBinary);
relativePathTopBinary->c_str());
}
} else {
cmSystemTools::Error("Directory Information file not found");
@@ -1478,13 +1477,13 @@ void cmLocalUnixMakefileGenerator3::CheckMultipleOutputs(bool verbose)
cmMakefile* mf = this->Makefile;
// Get the string listing the multiple output pairs.
const char* pairs_string = mf->GetDefinition("CMAKE_MULTIPLE_OUTPUT_PAIRS");
cmProp pairs_string = mf->GetDefinition("CMAKE_MULTIPLE_OUTPUT_PAIRS");
if (!pairs_string) {
return;
}
// Convert the string to a list and preserve empty entries.
std::vector<std::string> pairs = cmExpandedList(pairs_string, true);
std::vector<std::string> pairs = cmExpandedList(*pairs_string, true);
for (auto i = pairs.begin(); i != pairs.end() && (i + 1) != pairs.end();) {
const std::string& depender = *i++;
const std::string& dependee = *i++;
@@ -1650,9 +1649,9 @@ void cmLocalUnixMakefileGenerator3::WriteLocalAllRules(
recursiveTarget = cmStrCat(this->GetCurrentBinaryDirectory(), "/preinstall");
commands.clear();
depends.clear();
const char* noall =
cmProp noall =
this->Makefile->GetDefinition("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY");
if (!noall || cmIsOff(noall)) {
if (cmIsOff(noall)) {
// Drive the build before installing.
depends.emplace_back("all");
} else if (regenerate) {
@@ -1700,11 +1699,11 @@ void cmLocalUnixMakefileGenerator3::ClearDependencies(cmMakefile* mf,
bool verbose)
{
// Get the list of target files to check
const char* infoDef = mf->GetDefinition("CMAKE_DEPEND_INFO_FILES");
cmProp infoDef = mf->GetDefinition("CMAKE_DEPEND_INFO_FILES");
if (!infoDef) {
return;
}
std::vector<std::string> files = cmExpandedList(infoDef);
std::vector<std::string> files = cmExpandedList(*infoDef);
// Each depend information file corresponds to a target. Clear the
// dependencies for that target.
@@ -1808,10 +1807,10 @@ void cmLocalUnixMakefileGenerator3::WriteDependLanguageInfo(
// Tell the dependency scanner what compiler is used.
std::string cidVar =
cmStrCat("CMAKE_", implicitLang.first, "_COMPILER_ID");
const char* cid = this->Makefile->GetDefinition(cidVar);
cmProp cid = this->Makefile->GetDefinition(cidVar);
if (cmNonempty(cid)) {
cmakefileStream << "set(CMAKE_" << implicitLang.first
<< "_COMPILER_ID \"" << cid << "\")\n";
<< "_COMPILER_ID \"" << *cid << "\")\n";
}
if (implicitLang.first == "Fortran") {
Source/cmLocalVisualStudio7Generator.cxx
+8 -6
View File
@@ -593,8 +593,10 @@ void cmLocalVisualStudio7Generator::WriteConfiguration(
std::ostream& fout, const std::string& configName,
const std::string& libName, cmGeneratorTarget* target)
{
const char* mfcFlag = this->Makefile->GetDefinition("CMAKE_MFC_FLAG");
if (!mfcFlag) {
std::string mfcFlag;
if (cmProp p = this->Makefile->GetDefinition("CMAKE_MFC_FLAG")) {
mfcFlag = *p;
} else {
mfcFlag = "0";
}
cmGlobalVisualStudio7Generator* gg =
@@ -1087,9 +1089,9 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(
}
}
std::string stackVar = cmStrCat("CMAKE_", linkLanguage, "_STACK_SIZE");
const char* stackVal = this->Makefile->GetDefinition(stackVar);
cmProp stackVal = this->Makefile->GetDefinition(stackVar);
if (stackVal) {
fout << "\t\t\t\tStackReserveSize=\"" << stackVal << "\"\n";
fout << "\t\t\t\tStackReserveSize=\"" << *stackVal << "\"\n";
}
temp = cmStrCat(
target->GetDirectory(configName, cmStateEnums::ImportLibraryArtifact),
@@ -1176,9 +1178,9 @@ void cmLocalVisualStudio7Generator::OutputBuildTool(
<< "\"\n";
}
std::string stackVar = cmStrCat("CMAKE_", linkLanguage, "_STACK_SIZE");
const char* stackVal = this->Makefile->GetDefinition(stackVar);
cmProp stackVal = this->Makefile->GetDefinition(stackVar);
if (stackVal) {
fout << "\t\t\t\tStackReserveSize=\"" << stackVal << "\"";
fout << "\t\t\t\tStackReserveSize=\"" << *stackVal << "\"";
}
temp = cmStrCat(
target->GetDirectory(configName, cmStateEnums::ImportLibraryArtifact),
Source/cmLocalVisualStudioGenerator.cxx
+2 -3
View File
@@ -172,13 +172,12 @@ std::string cmLocalVisualStudioGenerator::ConstructScript(
// for visual studio IDE add extra stuff to the PATH
// if CMAKE_MSVCIDE_RUN_PATH is set.
if (this->Makefile->GetDefinition("MSVC_IDE")) {
const char* extraPath =
this->Makefile->GetDefinition("CMAKE_MSVCIDE_RUN_PATH");
cmProp extraPath = this->Makefile->GetDefinition("CMAKE_MSVCIDE_RUN_PATH");
if (extraPath) {
script += newline;
newline = newline_text;
script += "set PATH=";
script += extraPath;
script += *extraPath;
script += ";%PATH%";
}
}
Source/cmMakefile.cxx
+50 -59
View File
@@ -194,7 +194,7 @@ void cmMakefile::MaybeWarnCMP0074(std::string const& pkg)
{
// Warn if a <pkg>_ROOT variable we may use is set.
std::string const varName = pkg + "_ROOT";
const char* var = this->GetDefinition(varName);
cmProp var = this->GetDefinition(varName);
std::string env;
cmSystemTools::GetEnv(varName, env);
@@ -205,7 +205,7 @@ void cmMakefile::MaybeWarnCMP0074(std::string const& pkg)
w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0074) << "\n";
if (haveVar) {
w << "CMake variable " << varName << " is set to:\n"
<< " " << var << "\n";
<< " " << *var << "\n";
}
if (haveEnv) {
w << "Environment variable " << varName << " is set to:\n"
@@ -441,9 +441,9 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff,
// Check for maximum recursion depth.
int depth = CMake_DEFAULT_RECURSION_LIMIT;
const char* depthStr = this->GetDefinition("CMAKE_MAXIMUM_RECURSION_DEPTH");
cmProp depthStr = this->GetDefinition("CMAKE_MAXIMUM_RECURSION_DEPTH");
if (depthStr) {
std::istringstream s(depthStr);
std::istringstream s(*depthStr);
int d;
if (s >> d) {
depth = d;
@@ -627,8 +627,8 @@ void cmMakefile::IncludeScope::EnforceCMP0011()
bool cmMakefile::ReadDependentFile(const std::string& filename,
bool noPolicyScope)
{
if (const char* def = this->GetDefinition("CMAKE_CURRENT_LIST_FILE")) {
this->AddDefinition("CMAKE_PARENT_LIST_FILE", def);
if (cmProp def = this->GetDefinition("CMAKE_CURRENT_LIST_FILE")) {
this->AddDefinition("CMAKE_PARENT_LIST_FILE", *def);
}
std::string filenametoread = cmSystemTools::CollapseFullPath(
filename, this->GetCurrentSourceDirectory());
@@ -891,9 +891,10 @@ void cmMakefile::DoGenerate(cmLocalGenerator& lg)
void cmMakefile::Generate(cmLocalGenerator& lg)
{
this->DoGenerate(lg);
const char* oldValue = this->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY");
cmProp oldValue = this->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY");
if (oldValue &&
cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, oldValue, "2.4")) {
cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, oldValue->c_str(),
"2.4")) {
this->GetCMakeInstance()->IssueMessage(
MessageType::FATAL_ERROR,
"You have set CMAKE_BACKWARDS_COMPATIBILITY to a CMake version less "
@@ -2378,8 +2379,10 @@ cmSourceGroup* cmMakefile::GetOrCreateSourceGroup(
cmSourceGroup* cmMakefile::GetOrCreateSourceGroup(const std::string& name)
{
const char* delimiters = this->GetDefinition("SOURCE_GROUP_DELIMITER");
if (delimiters == nullptr) {
std::string delimiters;
if (cmProp p = this->GetDefinition("SOURCE_GROUP_DELIMITER")) {
delimiters = *p;
} else {
delimiters = "/\\";
}
return this->GetOrCreateSourceGroup(cmTokenize(name, delimiters));
@@ -2523,21 +2526,21 @@ void cmMakefile::ExpandVariablesCMP0019()
bool cmMakefile::IsOn(const std::string& name) const
{
return cmIsOn(this->GetDef(name));
return cmIsOn(this->GetDefinition(name));
}
bool cmMakefile::IsSet(const std::string& name) const
{
const char* value = this->GetDefinition(name);
cmProp value = this->GetDefinition(name);
if (!value) {
return false;
}
if (!*value) {
if (value->empty()) {
return false;
}
if (cmIsNOTFOUND(value)) {
if (cmIsNOTFOUND(*value)) {
return false;
}
@@ -2546,31 +2549,29 @@ bool cmMakefile::IsSet(const std::string& name) const
bool cmMakefile::PlatformIs32Bit() const
{
if (const char* plat_abi =
this->GetDefinition("CMAKE_INTERNAL_PLATFORM_ABI")) {
if (strcmp(plat_abi, "ELF X32") == 0) {
if (cmProp plat_abi = this->GetDefinition("CMAKE_INTERNAL_PLATFORM_ABI")) {
if (*plat_abi == "ELF X32") {
return false;
}
}
if (const char* sizeof_dptr = this->GetDefinition("CMAKE_SIZEOF_VOID_P")) {
return atoi(sizeof_dptr) == 4;
if (cmProp sizeof_dptr = this->GetDefinition("CMAKE_SIZEOF_VOID_P")) {
return atoi(sizeof_dptr->c_str()) == 4;
}
return false;
}
bool cmMakefile::PlatformIs64Bit() const
{
if (const char* sizeof_dptr = this->GetDefinition("CMAKE_SIZEOF_VOID_P")) {
return atoi(sizeof_dptr) == 8;
if (cmProp sizeof_dptr = this->GetDefinition("CMAKE_SIZEOF_VOID_P")) {
return atoi(sizeof_dptr->c_str()) == 8;
}
return false;
}
bool cmMakefile::PlatformIsx32() const
{
if (const char* plat_abi =
this->GetDefinition("CMAKE_INTERNAL_PLATFORM_ABI")) {
if (strcmp(plat_abi, "ELF X32") == 0) {
if (cmProp plat_abi = this->GetDefinition("CMAKE_INTERNAL_PLATFORM_ABI")) {
if (*plat_abi == "ELF X32") {
return true;
}
}
@@ -2619,7 +2620,7 @@ const char* cmMakefile::GetSONameFlag(const std::string& language) const
name += language;
}
name += "_FLAG";
return GetDefinition(name);
return cmToCStr(GetDefinition(name));
}
bool cmMakefile::CanIWriteThisFile(std::string const& fileName) const
@@ -2642,7 +2643,7 @@ const std::string& cmMakefile::GetRequiredDefinition(
const std::string& name) const
{
static std::string const empty;
const std::string* def = GetDef(name);
const std::string* def = GetDefinition(name);
if (!def) {
cmSystemTools::Error("Error required internal CMake variable not "
"set, cmake may not be built correctly.\n"
@@ -2670,7 +2671,7 @@ bool cmMakefile::IsDefinitionSet(const std::string& name) const
return def != nullptr;
}
const std::string* cmMakefile::GetDef(const std::string& name) const
cmProp cmMakefile::GetDefinition(const std::string& name) const
{
cmProp def = this->StateSnapshot.GetDefinition(name);
if (!def) {
@@ -2699,19 +2700,10 @@ const std::string* cmMakefile::GetDef(const std::string& name) const
return def;
}
const char* cmMakefile::GetDefinition(const std::string& name) const
{
const std::string* def = GetDef(name);
if (!def) {
return nullptr;
}
return def->c_str();
}
const std::string& cmMakefile::GetSafeDefinition(const std::string& name) const
{
static std::string const empty;
const std::string* def = GetDef(name);
const std::string* def = GetDefinition(name);
if (!def) {
return empty;
}
@@ -2722,7 +2714,7 @@ bool cmMakefile::GetDefExpandList(const std::string& name,
std::vector<std::string>& out,
bool emptyArgs) const
{
cmProp def = this->GetDef(name);
cmProp def = this->GetDefinition(name);
if (!def) {
return false;
}
@@ -2875,12 +2867,12 @@ MessageType cmMakefile::ExpandVariablesInStringOld(
// Lookup the definition of VAR.
std::string var(first + 1, last - first - 2);
if (const char* val = this->GetDefinition(var)) {
if (cmProp val = this->GetDefinition(var)) {
// Store the value in the output escaping as requested.
if (escapeQuotes) {
source.append(cmEscapeQuotes(val));
source.append(cmEscapeQuotes(*val));
} else {
source.append(val);
source.append(*val);
}
}
@@ -3026,7 +3018,7 @@ MessageType cmMakefile::ExpandVariablesInStringNew(
if (filename && lookup == lineVar) {
varresult = std::to_string(line);
} else {
value = this->GetDef(lookup);
value = this->GetDefinition(lookup);
}
break;
case ENVIRONMENT:
@@ -3158,7 +3150,7 @@ MessageType cmMakefile::ExpandVariablesInStringNew(
if (filename && variable == lineVar) {
varresult = std::to_string(line);
} else {
const std::string* def = this->GetDef(variable);
const std::string* def = this->GetDefinition(variable);
if (def) {
varresult = *def;
} else if (!this->SuppressSideEffects) {
@@ -3676,19 +3668,18 @@ int cmMakefile::TryCompile(const std::string& srcdir,
cm.SetGeneratorToolset(this->GetSafeDefinition("CMAKE_GENERATOR_TOOLSET"));
cm.LoadCache();
if (!cm.GetGlobalGenerator()->IsMultiConfig()) {
if (const char* config =
if (cmProp config =
this->GetDefinition("CMAKE_TRY_COMPILE_CONFIGURATION")) {
// Tell the single-configuration generator which one to use.
// Add this before the user-provided CMake arguments in case
// one of the arguments is -DCMAKE_BUILD_TYPE=...
cm.AddCacheEntry("CMAKE_BUILD_TYPE", config, "Build configuration",
cmStateEnums::STRING);
cm.AddCacheEntry("CMAKE_BUILD_TYPE", config->c_str(),
"Build configuration", cmStateEnums::STRING);
}
}
const char* recursionDepth =
this->GetDefinition("CMAKE_MAXIMUM_RECURSION_DEPTH");
cmProp recursionDepth = this->GetDefinition("CMAKE_MAXIMUM_RECURSION_DEPTH");
if (recursionDepth) {
cm.AddCacheEntry("CMAKE_MAXIMUM_RECURSION_DEPTH", recursionDepth,
cm.AddCacheEntry("CMAKE_MAXIMUM_RECURSION_DEPTH", recursionDepth->c_str(),
"Maximum recursion depth", cmStateEnums::STRING);
}
// if cmake args were provided then pass them in
@@ -3821,9 +3812,9 @@ std::string cmMakefile::GetModulesFile(const std::string& filename,
std::string moduleInCMakeModulePath;
// Always search in CMAKE_MODULE_PATH:
const char* cmakeModulePath = this->GetDefinition("CMAKE_MODULE_PATH");
cmProp cmakeModulePath = this->GetDefinition("CMAKE_MODULE_PATH");
if (cmakeModulePath) {
std::vector<std::string> modulePath = cmExpandedList(cmakeModulePath);
std::vector<std::string> modulePath = cmExpandedList(*cmakeModulePath);
// Look through the possible module directories.
for (std::string itempl : modulePath) {
@@ -3862,14 +3853,14 @@ std::string cmMakefile::GetModulesFile(const std::string& filename,
}
if (!moduleInCMakeModulePath.empty() && !moduleInCMakeRoot.empty()) {
const char* currentFile = this->GetDefinition("CMAKE_CURRENT_LIST_FILE");
cmProp currentFile = this->GetDefinition("CMAKE_CURRENT_LIST_FILE");
std::string mods = cmSystemTools::GetCMakeRoot() + "/Modules/";
if (currentFile && cmSystemTools::IsSubDirectory(currentFile, mods)) {
if (currentFile && cmSystemTools::IsSubDirectory(*currentFile, mods)) {
switch (this->GetPolicyStatus(cmPolicies::CMP0017)) {
case cmPolicies::WARN: {
std::ostringstream e;
/* clang-format off */
e << "File " << currentFile << " includes "
e << "File " << *currentFile << " includes "
<< moduleInCMakeModulePath
<< " (found via CMAKE_MODULE_PATH) which shadows "
<< moduleInCMakeRoot << ". This may cause errors later on .\n"
@@ -3919,7 +3910,7 @@ void cmMakefile::ConfigureString(const std::string& input, std::string& output,
// Replace #cmakedefine instances.
if (this->cmDefineRegex.find(line)) {
const char* def = this->GetDefinition(this->cmDefineRegex.match(2));
cmProp def = this->GetDefinition(this->cmDefineRegex.match(2));
if (!cmIsOff(def)) {
const std::string indentation = this->cmDefineRegex.match(1);
cmSystemTools::ReplaceString(line, "#" + indentation + "cmakedefine",
@@ -3932,7 +3923,7 @@ void cmMakefile::ConfigureString(const std::string& input, std::string& output,
}
} else if (this->cmDefine01Regex.find(line)) {
const std::string indentation = this->cmDefine01Regex.match(1);
const char* def = this->GetDefinition(this->cmDefine01Regex.match(2));
cmProp def = this->GetDefinition(this->cmDefine01Regex.match(2));
cmSystemTools::ReplaceString(line, "#" + indentation + "cmakedefine01",
"#" + indentation + "define");
output += line;
@@ -4457,11 +4448,11 @@ static std::string const nMatchesVariable = "CMAKE_MATCH_COUNT";
void cmMakefile::ClearMatches()
{
const char* nMatchesStr = this->GetDefinition(nMatchesVariable);
cmProp nMatchesStr = this->GetDefinition(nMatchesVariable);
if (!nMatchesStr) {
return;
}
int nMatches = atoi(nMatchesStr);
int nMatches = atoi(nMatchesStr->c_str());
for (int i = 0; i <= nMatches; i++) {
std::string const& var = matchVariables[i];
std::string const& s = this->GetSafeDefinition(var);
@@ -4510,7 +4501,7 @@ cmPolicies::PolicyStatus cmMakefile::GetPolicyStatus(cmPolicies::PolicyID id,
bool cmMakefile::PolicyOptionalWarningEnabled(std::string const& var)
{
// Check for an explicit CMAKE_POLICY_WARNING_CMP<NNNN> setting.
if (const char* val = this->GetDefinition(var)) {
if (cmProp val = this->GetDefinition(var)) {
return cmIsOn(val);
}
// Enable optional policy warnings with --debug-output, --trace,
Source/cmMakefile.h
+1 -2
View File
@@ -515,8 +515,7 @@ public:
* If the variable is not found in this makefile instance, the
* cache is then queried.
*/
const char* GetDefinition(const std::string&) const;
const std::string* GetDef(const std::string&) const;
cmProp GetDefinition(const std::string&) const;
const std::string& GetSafeDefinition(const std::string&) const;
const std::string& GetRequiredDefinition(const std::string& name) const;
bool IsDefinitionSet(const std::string&) const;
Source/cmMakefileTargetGenerator.cxx
+40 -34
View File
@@ -257,14 +257,14 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
this->GeneratorTarget->GetExtraSources(extraSources, this->GetConfigName());
this->OSXBundleGenerator->GenerateMacOSXContentStatements(
extraSources, this->MacOSXContentGenerator.get(), this->GetConfigName());
const char* pchExtension =
this->Makefile->GetDefinition("CMAKE_PCH_EXTENSION");
cmProp pchExtension = this->Makefile->GetDefinition("CMAKE_PCH_EXTENSION");
std::vector<cmSourceFile const*> externalObjects;
this->GeneratorTarget->GetExternalObjects(externalObjects,
this->GetConfigName());
for (cmSourceFile const* sf : externalObjects) {
auto const& objectFileName = sf->GetFullPath();
if (!cmSystemTools::StringEndsWith(objectFileName, pchExtension)) {
if (!cmSystemTools::StringEndsWith(objectFileName,
cmToCStr(pchExtension))) {
this->ExternalObjects.push_back(objectFileName);
}
}
@@ -814,13 +814,13 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
langIncludes.size(),
this->GetIncludes(lang, this->GetConfigName()));
const char* eliminate[] = {
cmProp eliminate[] = {
this->Makefile->GetDefinition("CMAKE_START_TEMP_FILE"),
this->Makefile->GetDefinition("CMAKE_END_TEMP_FILE")
};
for (const char* el : eliminate) {
for (cmProp el : eliminate) {
if (el) {
cmSystemTools::ReplaceString(compileCommand, el, "");
cmSystemTools::ReplaceString(compileCommand, *el, "");
}
}
@@ -866,9 +866,12 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
}
if (cmNonempty(tidy)) {
run_iwyu += " --tidy=";
const char* driverMode = this->Makefile->GetDefinition(
"CMAKE_" + lang + "_CLANG_TIDY_DRIVER_MODE");
if (!cmNonempty(driverMode)) {
cmProp p = this->Makefile->GetDefinition("CMAKE_" + lang +
"_CLANG_TIDY_DRIVER_MODE");
std::string driverMode;
if (cmNonempty(p)) {
driverMode = *p;
} else {
driverMode = lang == "C" ? "gcc" : "g++";
}
run_iwyu += this->LocalGenerator->EscapeForShell(
@@ -977,10 +980,10 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
std::string preprocessRuleVar =
cmStrCat("CMAKE_", lang, "_CREATE_PREPROCESSED_SOURCE");
if (const char* preprocessRule =
if (cmProp preprocessRule =
this->Makefile->GetDefinition(preprocessRuleVar)) {
std::vector<std::string> preprocessCommands =
cmExpandedList(preprocessRule);
cmExpandedList(*preprocessRule);
std::string shellObjI = this->LocalGenerator->ConvertToOutputFormat(
objI, cmOutputConverter::SHELL);
@@ -1022,10 +1025,10 @@ void cmMakefileTargetGenerator::WriteObjectRuleFiles(
std::string assemblyRuleVar =
cmStrCat("CMAKE_", lang, "_CREATE_ASSEMBLY_SOURCE");
if (const char* assemblyRule =
if (cmProp assemblyRule =
this->Makefile->GetDefinition(assemblyRuleVar)) {
std::vector<std::string> assemblyCommands =
cmExpandedList(assemblyRule);
cmExpandedList(*assemblyRule);
std::string shellObjS = this->LocalGenerator->ConvertToOutputFormat(
objS, cmOutputConverter::SHELL);
@@ -1372,17 +1375,17 @@ void cmMakefileTargetGenerator::WriteObjectsVariable(
<< this->GeneratorTarget->GetName() << "\n"
<< variableName << " =";
std::string object;
const char* lineContinue =
this->Makefile->GetDefinition("CMAKE_MAKE_LINE_CONTINUE");
if (!lineContinue) {
std::string lineContinue;
if (cmProp p = this->Makefile->GetDefinition("CMAKE_MAKE_LINE_CONTINUE")) {
lineContinue = *p;
} else {
lineContinue = "\\";
}
const char* pchExtension =
this->Makefile->GetDefinition("CMAKE_PCH_EXTENSION");
cmProp pchExtension = this->Makefile->GetDefinition("CMAKE_PCH_EXTENSION");
for (std::string const& obj : this->Objects) {
if (cmSystemTools::StringEndsWith(obj, pchExtension)) {
if (cmSystemTools::StringEndsWith(obj, cmToCStr(pchExtension))) {
continue;
}
*this->BuildFileStream << " " << lineContinue << "\n";
@@ -1477,14 +1480,13 @@ private:
void cmMakefileTargetGenerator::WriteObjectsStrings(
std::vector<std::string>& objStrings, std::string::size_type limit)
{
const char* pchExtension =
this->Makefile->GetDefinition("CMAKE_PCH_EXTENSION");
cmProp pchExtension = this->Makefile->GetDefinition("CMAKE_PCH_EXTENSION");
cmMakefileTargetGeneratorObjectStrings helper(
objStrings, this->LocalGenerator,
this->LocalGenerator->GetStateSnapshot().GetDirectory(), limit);
for (std::string const& obj : this->Objects) {
if (cmSystemTools::StringEndsWith(obj, pchExtension)) {
if (cmSystemTools::StringEndsWith(obj, cmToCStr(pchExtension))) {
continue;
}
helper.Feed(obj);
@@ -1607,8 +1609,8 @@ std::string cmMakefileTargetGenerator::GetLinkRule(
cmStrCat("CMAKE_",
this->GeneratorTarget->GetLinkerLanguage(this->GetConfigName()),
"_GNUtoMS_RULE");
if (const char* rule = this->Makefile->GetDefinition(ruleVar)) {
linkRule += rule;
if (cmProp rule = this->Makefile->GetDefinition(ruleVar)) {
linkRule += *rule;
}
}
return linkRule;
@@ -1657,8 +1659,8 @@ bool cmMakefileTargetGenerator::CheckUseResponseFileForObjects(
// Check for an explicit setting one way or the other.
std::string const responseVar =
"CMAKE_" + l + "_USE_RESPONSE_FILE_FOR_OBJECTS";
if (const char* val = this->Makefile->GetDefinition(responseVar)) {
if (*val) {
if (cmProp val = this->Makefile->GetDefinition(responseVar)) {
if (!val->empty()) {
return cmIsOn(val);
}
}
@@ -1696,8 +1698,8 @@ bool cmMakefileTargetGenerator::CheckUseResponseFileForLibraries(
// Check for an explicit setting one way or the other.
std::string const responseVar =
"CMAKE_" + l + "_USE_RESPONSE_FILE_FOR_LIBRARIES";
if (const char* val = this->Makefile->GetDefinition(responseVar)) {
if (*val) {
if (cmProp val = this->Makefile->GetDefinition(responseVar)) {
if (!val->empty()) {
return cmIsOn(val);
}
}
@@ -1758,8 +1760,10 @@ void cmMakefileTargetGenerator::CreateLinkLibs(
cmStrCat("CMAKE_",
this->GeneratorTarget->GetLinkerLanguage(this->GetConfigName()),
"_RESPONSE_FILE_LINK_FLAG");
const char* responseFlag = this->Makefile->GetDefinition(responseFlagVar);
if (!responseFlag) {
std::string responseFlag;
if (cmProp p = this->Makefile->GetDefinition(responseFlagVar)) {
responseFlag = *p;
} else {
responseFlag = "@";
}
@@ -1796,8 +1800,10 @@ void cmMakefileTargetGenerator::CreateObjectLists(
cmStrCat("CMAKE_",
this->GeneratorTarget->GetLinkerLanguage(this->GetConfigName()),
"_RESPONSE_FILE_LINK_FLAG");
const char* responseFlag = this->Makefile->GetDefinition(responseFlagVar);
if (!responseFlag) {
std::string responseFlag;
if (cmProp p = this->Makefile->GetDefinition(responseFlagVar)) {
responseFlag = *p;
} else {
responseFlag = "@";
}
@@ -1892,11 +1898,11 @@ void cmMakefileTargetGenerator::GenDefFile(
this->LocalGenerator->MaybeConvertToRelativePath(
this->LocalGenerator->GetCurrentBinaryDirectory(), objlist_file),
cmOutputConverter::SHELL);
const char* nm_executable = this->Makefile->GetDefinition("CMAKE_NM");
cmProp nm_executable = this->Makefile->GetDefinition("CMAKE_NM");
if (cmNonempty(nm_executable)) {
cmd += " --nm=";
cmd += this->LocalCommonGenerator->ConvertToOutputFormat(
nm_executable, cmOutputConverter::SHELL);
*nm_executable, cmOutputConverter::SHELL);
}
real_link_commands.insert(real_link_commands.begin(), cmd);
// create a list of obj files for the -E __create_def to read
Source/cmNinjaNormalTargetGenerator.cxx
+11 -11
View File
@@ -307,10 +307,10 @@ void cmNinjaNormalTargetGenerator::WriteLinkRule(bool useResponseFile,
// build response file name
std::string cmakeLinkVar = cmakeVarLang + "_RESPONSE_FILE_LINK_FLAG";
const char* flag = GetMakefile()->GetDefinition(cmakeLinkVar);
cmProp flag = GetMakefile()->GetDefinition(cmakeLinkVar);
if (flag) {
responseFlag = flag;
responseFlag = *flag;
} else {
responseFlag = "@";
}
@@ -478,15 +478,15 @@ std::vector<std::string> cmNinjaNormalTargetGenerator::ComputeLinkCmd(
// CMAKE_<lang>_CREATE_STATIC_LIBRARY_IPO define instead.
std::string linkCmdVar = this->GetGeneratorTarget()->GetCreateRuleVariable(
this->TargetLinkLanguage(config), config);
const char* linkCmd = mf->GetDefinition(linkCmdVar);
cmProp linkCmd = mf->GetDefinition(linkCmdVar);
if (linkCmd) {
std::string linkCmdStr = linkCmd;
std::string linkCmdStr = *linkCmd;
if (this->GetGeneratorTarget()->HasImplibGNUtoMS(config)) {
std::string ruleVar =
cmStrCat("CMAKE_", this->GeneratorTarget->GetLinkerLanguage(config),
"_GNUtoMS_RULE");
if (const char* rule = this->Makefile->GetDefinition(ruleVar)) {
linkCmdStr += rule;
if (cmProp rule = this->Makefile->GetDefinition(ruleVar)) {
linkCmdStr += *rule;
}
}
cmExpandList(linkCmdStr, linkCmds);
@@ -1027,8 +1027,8 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement(
gt->GetFullNameComponents(prefix, base, suffix, config);
std::string dbg_suffix = ".dbg";
// TODO: Where to document?
if (auto d = mf->GetDefinition("CMAKE_DEBUG_SYMBOL_SUFFIX")) {
dbg_suffix = d;
if (cmProp d = mf->GetDefinition("CMAKE_DEBUG_SYMBOL_SUFFIX")) {
dbg_suffix = *d;
}
vars["TARGET_PDB"] = base + suffix + dbg_suffix;
}
@@ -1091,11 +1091,11 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement(
cmd += this->GetLocalGenerator()->ConvertToOutputFormat(
obj_list_file, cmOutputConverter::SHELL);
const char* nm_executable = GetMakefile()->GetDefinition("CMAKE_NM");
cmProp nm_executable = GetMakefile()->GetDefinition("CMAKE_NM");
if (cmNonempty(nm_executable)) {
cmd += " --nm=";
cmd += this->LocalCommonGenerator->ConvertToOutputFormat(
nm_executable, cmOutputConverter::SHELL);
*nm_executable, cmOutputConverter::SHELL);
}
preLinkCmdLines.push_back(std::move(cmd));
@@ -1144,7 +1144,7 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement(
// build response file name
std::string cmakeLinkVar = cmakeVarLang + "_RESPONSE_FILE_LINK_FLAG";
const char* flag = GetMakefile()->GetDefinition(cmakeLinkVar);
cmProp flag = GetMakefile()->GetDefinition(cmakeLinkVar);
bool const lang_supports_response =
!(this->TargetLinkLanguage(config) == "RC" ||
Source/cmNinjaTargetGenerator.cxx
+17 -12
View File
@@ -762,9 +762,9 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
if (!mf->GetIsSourceFileTryCompile()) {
rule.DepType = "gcc";
rule.DepFile = "$DEP_FILE";
auto d = mf->GetDefinition("CMAKE_C_COMPILER");
cmProp d = mf->GetDefinition("CMAKE_C_COMPILER");
const std::string cl =
d ? d : mf->GetSafeDefinition("CMAKE_CXX_COMPILER");
d ? *d : mf->GetSafeDefinition("CMAKE_CXX_COMPILER");
cldeps = cmStrCat('"', cmSystemTools::GetCMClDepsCommand(), "\" ", lang,
' ', vars.Source, " $DEP_FILE $out \"",
mf->GetSafeDefinition("CMAKE_CL_SHOWINCLUDES_PREFIX"),
@@ -778,8 +778,9 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
if (!depfileFlags.empty()) {
cmSystemTools::ReplaceString(depfileFlags, "<DEPFILE>", "$DEP_FILE");
cmSystemTools::ReplaceString(depfileFlags, "<OBJECT>", "$out");
cmSystemTools::ReplaceString(depfileFlags, "<CMAKE_C_COMPILER>",
mf->GetDefinition("CMAKE_C_COMPILER"));
cmSystemTools::ReplaceString(
depfileFlags, "<CMAKE_C_COMPILER>",
cmToCStr(mf->GetDefinition("CMAKE_C_COMPILER")));
flags += cmStrCat(' ', depfileFlags);
}
}
@@ -847,9 +848,12 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang,
}
if (cmNonempty(tidy)) {
run_iwyu += " --tidy=";
const char* driverMode = this->Makefile->GetDefinition(
cmProp p = this->Makefile->GetDefinition(
cmStrCat("CMAKE_", lang, "_CLANG_TIDY_DRIVER_MODE"));
if (!cmNonempty(driverMode)) {
std::string driverMode;
if (cmNonempty(p)) {
driverMode = *p;
} else {
driverMode = lang == "C" ? "gcc" : "g++";
}
run_iwyu += this->GetLocalGenerator()->EscapeForShell(
@@ -942,15 +946,15 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements(
config);
}
if (firstForConfig) {
const char* pchExtension =
GetMakefile()->GetDefinition("CMAKE_PCH_EXTENSION");
cmProp pchExtension = GetMakefile()->GetDefinition("CMAKE_PCH_EXTENSION");
std::vector<cmSourceFile const*> externalObjects;
this->GeneratorTarget->GetExternalObjects(externalObjects, config);
for (cmSourceFile const* sf : externalObjects) {
auto objectFileName = this->GetGlobalGenerator()->ExpandCFGIntDir(
this->GetSourceFilePath(sf), config);
if (!cmSystemTools::StringEndsWith(objectFileName, pchExtension)) {
if (!cmSystemTools::StringEndsWith(objectFileName,
cmToCStr(pchExtension))) {
this->Configs[config].Objects.push_back(objectFileName);
}
}
@@ -1159,7 +1163,7 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
// build response file name
std::string cmakeLinkVar = cmStrCat(cmakeVarLang, "_RESPONSE_FILE_FLAG");
const char* flag = GetMakefile()->GetDefinition(cmakeLinkVar);
cmProp flag = GetMakefile()->GetDefinition(cmakeLinkVar);
bool const lang_supports_response =
!(language == "RC" || (language == "CUDA" && !flag));
@@ -1200,9 +1204,10 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement(
objBuild.Outputs.push_back(objectFileName);
if (firstForConfig) {
const char* pchExtension =
cmProp pchExtension =
this->GetMakefile()->GetDefinition("CMAKE_PCH_EXTENSION");
if (!cmSystemTools::StringEndsWith(objectFileName, pchExtension)) {
if (!cmSystemTools::StringEndsWith(objectFileName,
cmToCStr(pchExtension))) {
// Add this object to the list of object files.
this->Configs[config].Objects.push_back(objectFileName);
}
Source/cmParseArgumentsCommand.cxx
+3 -2
View File
@@ -13,6 +13,7 @@
#include "cmExecutionStatus.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmProperty.h"
#include "cmRange.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
@@ -195,7 +196,7 @@ bool cmParseArgumentsCommand(std::vector<std::string> const& args,
for (unsigned long i = argvStart; i < count; ++i) {
std::ostringstream argName;
argName << "ARGV" << i;
const char* arg = status.GetMakefile().GetDefinition(argName.str());
cmProp arg = status.GetMakefile().GetDefinition(argName.str());
if (!arg) {
status.GetMakefile().IssueMessage(MessageType::FATAL_ERROR,
"PARSE_ARGV called with " +
@@ -203,7 +204,7 @@ bool cmParseArgumentsCommand(std::vector<std::string> const& args,
cmSystemTools::SetFatalErrorOccured();
return true;
}
list.emplace_back(arg);
list.emplace_back(*arg);
}
}
Source/cmProjectCommand.cxx
+5 -4
View File
@@ -15,6 +15,7 @@
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmPolicies.h"
#include "cmProperty.h"
#include "cmStateTypes.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
@@ -302,7 +303,7 @@ bool cmProjectCommand(std::vector<std::string> const& args,
}
std::string vw;
for (std::string const& i : vv) {
const char* const v = mf.GetDefinition(i);
cmProp v = mf.GetDefinition(i);
if (cmNonempty(v)) {
if (cmp0048 == cmPolicies::WARN) {
if (!injectedProjectCommand) {
@@ -352,12 +353,12 @@ static bool IncludeByVariable(cmExecutionStatus& status,
const std::string& variable)
{
cmMakefile& mf = status.GetMakefile();
const char* const include = mf.GetDefinition(variable);
cmProp include = mf.GetDefinition(variable);
if (!include) {
return true;
}
const bool readit = mf.ReadDependentFile(include);
const bool readit = mf.ReadDependentFile(*include);
if (readit) {
return true;
}
@@ -366,7 +367,7 @@ static bool IncludeByVariable(cmExecutionStatus& status,
return true;
}
status.SetError(cmStrCat("could not find file:\n ", include));
status.SetError(cmStrCat("could not find file:\n ", *include));
return false;
}
Source/cmProperty.h
+10
View File
@@ -26,4 +26,14 @@ public:
using cmProp = const std::string*;
inline const char* cmToCStr(cmProp p)
{
return p ? p->c_str() : nullptr;
}
inline const char* cmToCStrSafe(cmProp p)
{
return p ? p->c_str() : "";
}
#endif
Source/cmQtAutoGenInitializer.cxx
+2 -2
View File
@@ -1758,8 +1758,8 @@ cmQtAutoGenInitializer::GetQtVersion(cmGeneratorTarget const* target)
// Read versions from variables
for (auto const& keyPair : keys) {
addVersion(target->Makefile->GetDef(std::string(keyPair.first)),
target->Makefile->GetDef(std::string(keyPair.second)));
addVersion(target->Makefile->GetDefinition(std::string(keyPair.first)),
target->Makefile->GetDefinition(std::string(keyPair.second)));
}
// Read versions from directory properties
Source/cmRemoveCommand.cxx
+3 -2
View File
@@ -4,6 +4,7 @@
#include "cmExecutionStatus.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmStringAlgorithms.h"
// cmRemoveCommand
@@ -16,7 +17,7 @@ bool cmRemoveCommand(std::vector<std::string> const& args,
std::string const& variable = args[0]; // VAR is always first
// get the old value
const char* cacheValue = status.GetMakefile().GetDefinition(variable);
cmProp cacheValue = status.GetMakefile().GetDefinition(variable);
// if there is no old value then return
if (!cacheValue) {
@@ -24,7 +25,7 @@ bool cmRemoveCommand(std::vector<std::string> const& args,
}
// expand the variable
std::vector<std::string> const varArgsExpanded = cmExpandedList(cacheValue);
std::vector<std::string> const varArgsExpanded = cmExpandedList(*cacheValue);
// expand the args
// check for REMOVE(VAR v1 v2 ... vn)
Source/cmSearchPath.cxx
+8 -7
View File
@@ -8,6 +8,7 @@
#include "cmFindCommon.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
@@ -77,8 +78,8 @@ void cmSearchPath::AddCMakePath(const std::string& variable)
assert(this->FC != nullptr);
// Get a path from a CMake variable.
if (const char* value = this->FC->Makefile->GetDefinition(variable)) {
std::vector<std::string> expanded = cmExpandedList(value);
if (cmProp value = this->FC->Makefile->GetDefinition(variable)) {
std::vector<std::string> expanded = cmExpandedList(*value);
for (std::string const& p : expanded) {
this->AddPathInternal(
@@ -101,8 +102,8 @@ void cmSearchPath::AddCMakePrefixPath(const std::string& variable)
assert(this->FC != nullptr);
// Get a path from a CMake variable.
if (const char* value = this->FC->Makefile->GetDefinition(variable)) {
std::vector<std::string> expanded = cmExpandedList(value);
if (cmProp value = this->FC->Makefile->GetDefinition(variable)) {
std::vector<std::string> expanded = cmExpandedList(*value);
this->AddPrefixPaths(
expanded, this->FC->Makefile->GetCurrentSourceDirectory().c_str());
@@ -178,15 +179,15 @@ void cmSearchPath::AddPrefixPaths(const std::vector<std::string>& paths,
dir += "/";
}
if (subdir == "include" || subdir == "lib") {
const char* arch =
cmProp arch =
this->FC->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE");
if (cmNonempty(arch)) {
if (this->FC->Makefile->IsDefinitionSet("CMAKE_SYSROOT") &&
this->FC->Makefile->IsDefinitionSet(
"CMAKE_PREFIX_LIBRARY_ARCHITECTURE")) {
this->AddPathInternal(cmStrCat('/', arch, dir, subdir), base);
this->AddPathInternal(cmStrCat('/', *arch, dir, subdir), base);
} else {
this->AddPathInternal(cmStrCat(dir, subdir, '/', arch), base);
this->AddPathInternal(cmStrCat(dir, subdir, '/', *arch), base);
}
}
}
Source/cmSeparateArgumentsCommand.cxx
+3 -2
View File
@@ -6,6 +6,7 @@
#include "cmExecutionStatus.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
@@ -65,8 +66,8 @@ bool cmSeparateArgumentsCommand(std::vector<std::string> const& args,
if (mode == ModeOld) {
// Original space-replacement version of command.
if (const char* def = status.GetMakefile().GetDefinition(var)) {
std::string value = def;
if (cmProp def = status.GetMakefile().GetDefinition(var)) {
std::string value = *def;
std::replace(value.begin(), value.end(), ' ', ';');
status.GetMakefile().AddDefinition(var, value);
}
Source/cmSiteNameCommand.cxx
+4 -3
View File
@@ -6,6 +6,7 @@
#include "cmExecutionStatus.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmStateTypes.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
@@ -26,15 +27,15 @@ bool cmSiteNameCommand(std::vector<std::string> const& args,
paths.emplace_back("/sbin");
paths.emplace_back("/usr/local/bin");
const char* cacheValue = status.GetMakefile().GetDefinition(args[0]);
cmProp cacheValue = status.GetMakefile().GetDefinition(args[0]);
if (cacheValue) {
return true;
}
const char* temp = status.GetMakefile().GetDefinition("HOSTNAME");
cmProp temp = status.GetMakefile().GetDefinition("HOSTNAME");
std::string hostname_cmd;
if (temp) {
hostname_cmd = temp;
hostname_cmd = *temp;
} else {
hostname_cmd = cmSystemTools::FindProgram("hostname", paths);
}
Source/cmStandardLevelResolver.cxx
+13 -13
View File
@@ -63,7 +63,7 @@ struct StanardLevelComputer
const auto& stds = this->Levels;
const auto& stdsStrings = this->LevelsAsStrings;
const char* defaultStd = makefile->GetDefinition(
cmProp defaultStd = makefile->GetDefinition(
cmStrCat("CMAKE_", this->Language, "_STANDARD_DEFAULT"));
if (!cmNonempty(defaultStd)) {
// this compiler has no notion of language standard levels
@@ -93,8 +93,7 @@ struct StanardLevelComputer
std::string option_flag = cmStrCat(
"CMAKE_", this->Language, *standardProp, "_", type, "_COMPILE_OPTION");
const char* opt =
target->Target->GetMakefile()->GetDefinition(option_flag);
cmProp opt = target->Target->GetMakefile()->GetDefinition(option_flag);
if (!opt) {
std::ostringstream e;
e << "Target \"" << target->GetName()
@@ -118,7 +117,7 @@ struct StanardLevelComputer
int defaultValue = -1;
try {
standardValue = std::stoi(standardStr);
defaultValue = std::stoi(defaultStd);
defaultValue = std::stoi(*defaultStd);
} catch (std::invalid_argument&) {
// fall through as we want an error
// when we can't find the bad value in the `stds` vector
@@ -139,7 +138,7 @@ struct StanardLevelComputer
if (defaultStdIt == cm::cend(stds)) {
std::string e = cmStrCat("CMAKE_", this->Language,
"_STANDARD_DEFAULT is set to invalid value '",
defaultStd, "'");
*defaultStd, "'");
makefile->IssueMessage(MessageType::INTERNAL_ERROR, e);
return std::string{};
}
@@ -185,7 +184,7 @@ struct StanardLevelComputer
cmProp existingStandard = currentLangStandardValue;
if (existingStandard == nullptr) {
cmProp defaultStandard = makefile->GetDef(
cmProp defaultStandard = makefile->GetDefinition(
cmStrCat("CMAKE_", this->Language, "_STANDARD_DEFAULT"));
if (cmNonempty(defaultStandard)) {
existingStandard = defaultStandard;
@@ -228,7 +227,7 @@ struct StanardLevelComputer
std::string const& config,
std::string const& feature) const
{
cmProp defaultStandard = makefile->GetDef(
cmProp defaultStandard = makefile->GetDefinition(
cmStrCat("CMAKE_", this->Language, "_STANDARD_DEFAULT"));
if (!defaultStandard) {
makefile->IssueMessage(
@@ -280,9 +279,9 @@ struct StanardLevelComputer
std::string prefix = cmStrCat("CMAKE_", this->Language);
StandardNeeded maxLevel = { -1, -1 };
for (size_t i = 0; i < this->Levels.size(); ++i) {
if (const char* prop = makefile->GetDefinition(
if (cmProp prop = makefile->GetDefinition(
cmStrCat(prefix, this->LevelsAsStrings[i], "_COMPILE_FEATURES"))) {
std::vector<std::string> props = cmExpandedList(prop);
std::vector<std::string> props = cmExpandedList(*prop);
if (cm::contains(props, feature)) {
maxLevel = { static_cast<int>(i), this->Levels[i] };
}
@@ -390,9 +389,10 @@ bool cmStandardLevelResolver::CheckCompileFeaturesAvailable(
std::ostringstream e;
e << "The compiler feature \"" << feature << "\" is not known to " << lang
<< " compiler\n\""
<< this->Makefile->GetDefinition("CMAKE_" + lang + "_COMPILER_ID")
<< this->Makefile->GetSafeDefinition("CMAKE_" + lang + "_COMPILER_ID")
<< "\"\nversion "
<< this->Makefile->GetDefinition("CMAKE_" + lang + "_COMPILER_VERSION")
<< this->Makefile->GetSafeDefinition("CMAKE_" + lang +
"_COMPILER_VERSION")
<< ".";
if (error) {
*error = e.str();
@@ -469,7 +469,7 @@ const char* cmStandardLevelResolver::CompileFeaturesAvailable(
return nullptr;
}
const char* featuresKnown =
cmProp featuresKnown =
this->Makefile->GetDefinition("CMAKE_" + lang + "_COMPILE_FEATURES");
if (!cmNonempty(featuresKnown)) {
@@ -492,7 +492,7 @@ const char* cmStandardLevelResolver::CompileFeaturesAvailable(
}
return nullptr;
}
return featuresKnown;
return cmToCStr(featuresKnown);
}
bool cmStandardLevelResolver::GetNewRequiredStandard(
Source/cmState.cxx
+3 -2
View File
@@ -469,9 +469,10 @@ void cmState::AddUnexpectedCommand(std::string const& name, const char* error)
name,
[name, error](std::vector<cmListFileArgument> const&,
cmExecutionStatus& status) -> bool {
const char* versionValue =
cmProp versionValue =
status.GetMakefile().GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION");
if (name == "endif" && (!versionValue || atof(versionValue) <= 1.4)) {
if (name == "endif" &&
(!versionValue || atof(versionValue->c_str()) <= 1.4)) {
return true;
}
status.SetError(error);
Source/cmStringCommand.cxx
+4 -7
View File
@@ -20,6 +20,7 @@
#include "cmGeneratorExpression.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmProperty.h"
#include "cmRange.h"
#include "cmStringAlgorithms.h"
#include "cmStringReplaceHelper.h"
@@ -535,11 +536,7 @@ bool HandleAppendCommand(std::vector<std::string> const& args,
const std::string& variable = args[1];
std::string value;
const char* oldValue = status.GetMakefile().GetDefinition(variable);
if (oldValue) {
value = oldValue;
}
std::string value = status.GetMakefile().GetSafeDefinition(variable);
value += cmJoin(cmMakeRange(args).advance(2), std::string());
status.GetMakefile().AddDefinition(variable, value);
return true;
@@ -561,9 +558,9 @@ bool HandlePrependCommand(std::vector<std::string> const& args,
const std::string& variable = args[1];
std::string value = cmJoin(cmMakeRange(args).advance(2), std::string());
const char* oldValue = status.GetMakefile().GetDefinition(variable);
cmProp oldValue = status.GetMakefile().GetDefinition(variable);
if (oldValue) {
value += oldValue;
value += *oldValue;
}
status.GetMakefile().AddDefinition(variable, value);
return true;
Source/cmTarget.cxx
+8 -8
View File
@@ -265,16 +265,16 @@ cmTarget::cmTarget(std::string const& name, cmStateEnums::TargetType type,
auto initProp = [this, mf, &defKey](const std::string& property) {
// Replace everything after "CMAKE_"
defKey.replace(defKey.begin() + 6, defKey.end(), property);
if (const char* value = mf->GetDefinition(defKey)) {
this->SetProperty(property, value);
if (cmProp value = mf->GetDefinition(defKey)) {
this->SetProperty(property, *value);
}
};
auto initPropValue = [this, mf, &defKey](const std::string& property,
const char* default_value) {
// Replace everything after "CMAKE_"
defKey.replace(defKey.begin() + 6, defKey.end(), property);
if (const char* value = mf->GetDefinition(defKey)) {
this->SetProperty(property, value);
if (cmProp value = mf->GetDefinition(defKey)) {
this->SetProperty(property, *value);
} else if (default_value) {
this->SetProperty(property, default_value);
}
@@ -524,11 +524,11 @@ cmTarget::cmTarget(std::string const& name, cmStateEnums::TargetType type,
// check for "CMAKE_VS_GLOBALS" variable and set up target properties
// if any
const char* globals = mf->GetDefinition("CMAKE_VS_GLOBALS");
cmProp globals = mf->GetDefinition("CMAKE_VS_GLOBALS");
if (globals) {
const std::string genName = mf->GetGlobalGenerator()->GetName();
if (cmHasLiteralPrefix(genName, "Visual Studio")) {
std::vector<std::string> props = cmExpandedList(globals);
std::vector<std::string> props = cmExpandedList(*globals);
const std::string vsGlobal = "VS_GLOBAL_";
for (const std::string& i : props) {
// split NAME=VALUE
@@ -1017,9 +1017,9 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf, std::string const& lib,
this->GetPolicyStatusCMP0073() == cmPolicies::WARN)) {
std::string targetEntry = cmStrCat(impl->Name, "_LIB_DEPENDS");
std::string dependencies;
const char* old_val = mf.GetDefinition(targetEntry);
cmProp old_val = mf.GetDefinition(targetEntry);
if (old_val) {
dependencies += old_val;
dependencies += *old_val;
}
switch (llt) {
case GENERAL_LibraryType:
Source/cmTargetLinkLibrariesCommand.cxx
+4 -4
View File
@@ -2,7 +2,6 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmTargetLinkLibrariesCommand.h"
#include <cstring>
#include <memory>
#include <sstream>
#include <unordered_set>
@@ -14,6 +13,7 @@
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmPolicies.h"
#include "cmProperty.h"
#include "cmState.h"
#include "cmStateTypes.h"
#include "cmStringAlgorithms.h"
@@ -277,12 +277,12 @@ bool cmTargetLinkLibrariesCommand(std::vector<std::string> const& args,
// with old versions of CMake and new)
llt = GENERAL_LibraryType;
std::string linkType = cmStrCat(args[0], "_LINK_TYPE");
const char* linkTypeString = mf.GetDefinition(linkType);
cmProp linkTypeString = mf.GetDefinition(linkType);
if (linkTypeString) {
if (strcmp(linkTypeString, "debug") == 0) {
if (*linkTypeString == "debug") {
llt = DEBUG_LibraryType;
}
if (strcmp(linkTypeString, "optimized") == 0) {
if (*linkTypeString == "optimized") {
llt = OPTIMIZED_LibraryType;
}
}
Source/cmTryRunCommand.cxx
+5 -5
View File
@@ -146,10 +146,10 @@ bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv,
if (!this->OutputVariable.empty()) {
// if the TryCompileCore saved output in this outputVariable then
// prepend that output to this output
const char* compileOutput =
cmProp compileOutput =
this->Makefile->GetDefinition(this->OutputVariable);
if (compileOutput) {
runOutputContents = compileOutput + runOutputContents;
runOutputContents = *compileOutput + runOutputContents;
}
this->Makefile->AddDefinition(this->OutputVariable, runOutputContents);
}
@@ -328,12 +328,12 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
file << comment << "\n\n";
file << "set( " << this->RunResultVariable << " \n \""
<< this->Makefile->GetDefinition(this->RunResultVariable)
<< this->Makefile->GetSafeDefinition(this->RunResultVariable)
<< "\"\n CACHE STRING \"Result from TRY_RUN\" FORCE)\n\n";
if (out) {
file << "set( " << internalRunOutputName << " \n \""
<< this->Makefile->GetDefinition(internalRunOutputName)
<< this->Makefile->GetSafeDefinition(internalRunOutputName)
<< "\"\n CACHE STRING \"Output from TRY_RUN\" FORCE)\n\n";
}
file.close();
@@ -354,6 +354,6 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
}
if (out) {
(*out) = this->Makefile->GetDefinition(internalRunOutputName);
(*out) = *this->Makefile->GetDefinition(internalRunOutputName);
}
}
Source/cmUtilitySourceCommand.cxx
+7 -5
View File
@@ -6,6 +6,7 @@
#include "cmExecutionStatus.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmState.h"
#include "cmStateTypes.h"
#include "cmStringAlgorithms.h"
@@ -24,7 +25,7 @@ bool cmUtilitySourceCommand(std::vector<std::string> const& args,
// The first argument is the cache entry name.
std::string const& cacheEntry = *arg++;
const char* cacheValue = status.GetMakefile().GetDefinition(cacheEntry);
cmProp cacheValue = status.GetMakefile().GetDefinition(cacheEntry);
// If it exists already and appears up to date then we are done. If
// the string contains "(IntDir)" but that is not the
// CMAKE_CFG_INTDIR setting then the value is out of date.
@@ -45,7 +46,7 @@ bool cmUtilitySourceCommand(std::vector<std::string> const& args,
} else {
cmState* state = status.GetMakefile().GetState();
haveCacheValue = (cacheValue &&
(strstr(cacheValue, "(IntDir)") == nullptr ||
(strstr(cacheValue->c_str(), "(IntDir)") == nullptr ||
(intDir == "$(IntDir)")) &&
(state->GetCacheMajorVersion() != 0 &&
state->GetCacheMinorVersion() != 0));
@@ -84,8 +85,9 @@ bool cmUtilitySourceCommand(std::vector<std::string> const& args,
std::string utilityDirectory =
status.GetMakefile().GetCurrentBinaryDirectory();
std::string exePath;
if (auto d = status.GetMakefile().GetDefinition("EXECUTABLE_OUTPUT_PATH")) {
exePath = d;
if (cmProp d =
status.GetMakefile().GetDefinition("EXECUTABLE_OUTPUT_PATH")) {
exePath = *d;
}
if (!exePath.empty()) {
utilityDirectory = exePath;
@@ -96,7 +98,7 @@ bool cmUtilitySourceCommand(std::vector<std::string> const& args,
// Construct the cache entry for the executable's location.
std::string utilityExecutable = utilityDirectory + "/" + cmakeCFGout + "/" +
utilityName +
status.GetMakefile().GetDefinition("CMAKE_EXECUTABLE_SUFFIX");
*status.GetMakefile().GetDefinition("CMAKE_EXECUTABLE_SUFFIX");
// make sure we remove any /./ in the name
cmSystemTools::ReplaceString(utilityExecutable, "/./", "/");
Source/cmVariableRequiresCommand.cxx
+3 -2
View File
@@ -4,6 +4,7 @@
#include "cmExecutionStatus.h"
#include "cmMakefile.h"
#include "cmProperty.h"
#include "cmState.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
@@ -37,11 +38,11 @@ bool cmVariableRequiresCommand(std::vector<std::string> const& args,
}
}
}
const char* reqVar = status.GetMakefile().GetDefinition(resultVariable);
cmProp reqVar = status.GetMakefile().GetDefinition(resultVariable);
// if reqVar is unset, then set it to requirementsMet
// if reqVar is set to true, but requirementsMet is false , then
// set reqVar to false.
if (!reqVar || (!requirementsMet && status.GetMakefile().IsOn(reqVar))) {
if (!reqVar || (!requirementsMet && status.GetMakefile().IsOn(*reqVar))) {
status.GetMakefile().AddDefinitionBool(resultVariable, requirementsMet);
}
Source/cmVariableWatchCommand.cxx
+3 -2
View File
@@ -10,6 +10,7 @@
#include "cmListFileCache.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmProperty.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmVariableWatch.h"
@@ -45,7 +46,7 @@ void cmVariableWatchCommandVariableAccessed(const std::string& variable,
std::string stack = *mf->GetProperty("LISTFILE_STACK");
if (!data->Command.empty()) {
cmListFileFunction newLFF;
const char* const currentListFile =
cmProp const currentListFile =
mf->GetDefinition("CMAKE_CURRENT_LIST_FILE");
const auto fakeLineNo =
std::numeric_limits<decltype(cmListFileArgument::Line)>::max();
@@ -53,7 +54,7 @@ void cmVariableWatchCommandVariableAccessed(const std::string& variable,
{ variable, cmListFileArgument::Quoted, fakeLineNo },
{ accessString, cmListFileArgument::Quoted, fakeLineNo },
{ newValue ? newValue : "", cmListFileArgument::Quoted, fakeLineNo },
{ currentListFile, cmListFileArgument::Quoted, fakeLineNo },
{ *currentListFile, cmListFileArgument::Quoted, fakeLineNo },
{ stack, cmListFileArgument::Quoted, fakeLineNo }
};
newLFF.Name = data->Command;
Source/cmVisualStudio10TargetGenerator.cxx
+18 -18
View File
@@ -1226,9 +1226,9 @@ void cmVisualStudio10TargetGenerator::WriteMSToolConfigurationValues(
Elem& e1, std::string const& config)
{
cmGlobalVisualStudio10Generator* gg = this->GlobalGenerator;
const char* mfcFlag = this->Makefile->GetDefinition("CMAKE_MFC_FLAG");
cmProp mfcFlag = this->Makefile->GetDefinition("CMAKE_MFC_FLAG");
if (mfcFlag) {
std::string const mfcFlagValue = mfcFlag;
std::string const mfcFlagValue = *mfcFlag;
std::string useOfMfcValue = "false";
if (this->GeneratorTarget->GetType() <= cmStateEnums::OBJECT_LIBRARY) {
@@ -2603,42 +2603,42 @@ void cmVisualStudio10TargetGenerator::WritePathAndIncrementalLinkOptions(
e1.WritePlatformConfigTag("IntDir", cond, intermediateDir);
if (const char* sdkExecutableDirectories = this->Makefile->GetDefinition(
if (cmProp sdkExecutableDirectories = this->Makefile->GetDefinition(
"CMAKE_VS_SDK_EXECUTABLE_DIRECTORIES")) {
e1.WritePlatformConfigTag("ExecutablePath", cond,
sdkExecutableDirectories);
*sdkExecutableDirectories);
}
if (const char* sdkIncludeDirectories = this->Makefile->GetDefinition(
if (cmProp sdkIncludeDirectories = this->Makefile->GetDefinition(
"CMAKE_VS_SDK_INCLUDE_DIRECTORIES")) {
e1.WritePlatformConfigTag("IncludePath", cond, sdkIncludeDirectories);
e1.WritePlatformConfigTag("IncludePath", cond, *sdkIncludeDirectories);
}
if (const char* sdkReferenceDirectories = this->Makefile->GetDefinition(
if (cmProp sdkReferenceDirectories = this->Makefile->GetDefinition(
"CMAKE_VS_SDK_REFERENCE_DIRECTORIES")) {
e1.WritePlatformConfigTag("ReferencePath", cond,
sdkReferenceDirectories);
*sdkReferenceDirectories);
}
if (const char* sdkLibraryDirectories = this->Makefile->GetDefinition(
if (cmProp sdkLibraryDirectories = this->Makefile->GetDefinition(
"CMAKE_VS_SDK_LIBRARY_DIRECTORIES")) {
e1.WritePlatformConfigTag("LibraryPath", cond, sdkLibraryDirectories);
e1.WritePlatformConfigTag("LibraryPath", cond, *sdkLibraryDirectories);
}
if (const char* sdkLibraryWDirectories = this->Makefile->GetDefinition(
if (cmProp sdkLibraryWDirectories = this->Makefile->GetDefinition(
"CMAKE_VS_SDK_LIBRARY_WINRT_DIRECTORIES")) {
e1.WritePlatformConfigTag("LibraryWPath", cond,
sdkLibraryWDirectories);
*sdkLibraryWDirectories);
}
if (const char* sdkSourceDirectories =
if (cmProp sdkSourceDirectories =
this->Makefile->GetDefinition("CMAKE_VS_SDK_SOURCE_DIRECTORIES")) {
e1.WritePlatformConfigTag("SourcePath", cond, sdkSourceDirectories);
e1.WritePlatformConfigTag("SourcePath", cond, *sdkSourceDirectories);
}
if (const char* sdkExcludeDirectories = this->Makefile->GetDefinition(
if (cmProp sdkExcludeDirectories = this->Makefile->GetDefinition(
"CMAKE_VS_SDK_EXCLUDE_DIRECTORIES")) {
e1.WritePlatformConfigTag("ExcludePath", cond, sdkExcludeDirectories);
e1.WritePlatformConfigTag("ExcludePath", cond, *sdkExcludeDirectories);
}
std::string name =
@@ -3769,9 +3769,9 @@ bool cmVisualStudio10TargetGenerator::ComputeLinkOptions(
};
}
if (const char* stackVal = this->Makefile->GetDefinition(
if (cmProp stackVal = this->Makefile->GetDefinition(
"CMAKE_" + linkLanguage + "_STACK_SIZE")) {
linkOptions.AddFlag("StackReserveSize", stackVal);
linkOptions.AddFlag("StackReserveSize", *stackVal);
}
linkOptions.AddFlag("GenerateDebugInformation", "false");
Source/cmake.cxx
+2 -1
View File
@@ -2286,7 +2286,8 @@ int cmake::CheckBuildSystem()
if (this->ClearBuildSystem) {
// Get the generator used for this build system.
const char* genName = mf.GetDefinition("CMAKE_DEPENDS_GENERATOR");
const char* genName =
cmToCStr(mf.GetDefinition("CMAKE_DEPENDS_GENERATOR"));
if (!cmNonempty(genName)) {
genName = "Unix Makefiles";
}