mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-02-26 10:48:38 -06:00
Code Issues Packages Projects Releases Wiki Activity

cmGlobalGenerator: modernize memrory managemenbt

Browse Source
This commit is contained in:
Marc Chevrier
2019-12-29 11:36:48 +01:00
parent 15526d4b10
commit 5444a8095d
18 changed files with 115 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Source/cmExportBuildFileGenerator.cxx
View File

@@ -301,11 +301,10 @@ cmExportBuildFileGenerator::FindBuildExportInfo(cmGlobalGenerator* gg,
std::vector<std::string> exportFiles; std::vector<std::string> exportFiles;
std::string ns; std::string ns;
std::map<std::string, cmExportBuildFileGenerator*>& exportSets = auto& exportSets = gg->GetBuildExportSets();
gg->GetBuildExportSets();
for (auto const& exp : exportSets) { for (auto const& exp : exportSets) {
const cmExportBuildFileGenerator* exportSet = exp.second; const auto& exportSet = exp.second;
std::vector<std::string> targets; std::vector<std::string> targets;
exportSet->GetTargets(targets); exportSet->GetTargets(targets);
if (cmContains(targets, name)) { if (cmContains(targets, name)) {

14
Source/cmExportCommand.cxx
View File

@@ -6,6 +6,8 @@
#include <sstream> #include <sstream>
#include <utility> #include <utility>
#include <cm/memory>
#include "cmsys/RegularExpression.hxx" #include "cmsys/RegularExpression.hxx"
#include "cm_static_string_view.hxx" #include "cm_static_string_view.hxx"
@@ -182,11 +184,11 @@ bool cmExportCommand(std::vector<std::string> const& args,
} }
// Setup export file generation. // Setup export file generation.
cmExportBuildFileGenerator* ebfg = nullptr; std::unique_ptr<cmExportBuildFileGenerator> ebfg = nullptr;
if (android) { if (android) {
ebfg = new cmExportBuildAndroidMKGenerator; ebfg = cm::make_unique<cmExportBuildAndroidMKGenerator>();
} else { } else {
ebfg = new cmExportBuildFileGenerator; ebfg = cm::make_unique<cmExportBuildFileGenerator>();
} }
ebfg->SetExportFile(fname.c_str()); ebfg->SetExportFile(fname.c_str());
ebfg->SetNamespace(arguments.Namespace); ebfg->SetNamespace(arguments.Namespace);
@@ -196,7 +198,7 @@ bool cmExportCommand(std::vector<std::string> const& args,
} else { } else {
ebfg->SetTargets(targets); ebfg->SetTargets(targets);
} }
mf.AddExportBuildFileGenerator(ebfg); mf.AddExportBuildFileGenerator(ebfg.get());
ebfg->SetExportOld(arguments.ExportOld); ebfg->SetExportOld(arguments.ExportOld);
// Compute the set of configurations exported. // Compute the set of configurations exported.
@@ -209,9 +211,9 @@ bool cmExportCommand(std::vector<std::string> const& args,
ebfg->AddConfiguration(ct); ebfg->AddConfiguration(ct);
} }
if (exportSet != nullptr) { if (exportSet != nullptr) {
gg->AddBuildExportExportSet(ebfg); gg->AddBuildExportExportSet(std::move(ebfg));
} else { } else {
gg->AddBuildExportSet(ebfg); gg->AddBuildExportSet(std::move(ebfg));
} }
return true; return true;

4
Source/cmExportLibraryDependenciesCommand.cxx
View File

@@ -49,11 +49,11 @@ static void FinalAction(cmMakefile& makefile, std::string const& filename,
// the project. // the project.
cmake* cm = makefile.GetCMakeInstance(); cmake* cm = makefile.GetCMakeInstance();
cmGlobalGenerator* global = cm->GetGlobalGenerator(); cmGlobalGenerator* global = cm->GetGlobalGenerator();
const std::vector<cmMakefile*>& locals = global->GetMakefiles(); const auto& locals = global->GetMakefiles();
std::map<std::string, std::string> libDepsOld; std::map<std::string, std::string> libDepsOld;
std::map<std::string, std::string> libDepsNew; std::map<std::string, std::string> libDepsNew;
std::map<std::string, std::string> libTypes; std::map<std::string, std::string> libTypes;
for (cmMakefile* local : locals) { for (const auto& local : locals) {
for (auto const& tgt : local->GetTargets()) { for (auto const& tgt : local->GetTargets()) {
// Get the current target. // Get the current target.
cmTarget const& target = tgt.second; cmTarget const& target = tgt.second;

2
Source/cmFileAPICodemodel.cxx
View File

@@ -427,7 +427,7 @@ Json::Value Codemodel::DumpConfigurations()
Json::Value configurations = Json::arrayValue; Json::Value configurations = Json::arrayValue;
cmGlobalGenerator* gg = cmGlobalGenerator* gg =
this->FileAPI.GetCMakeInstance()->GetGlobalGenerator(); this->FileAPI.GetCMakeInstance()->GetGlobalGenerator();
auto makefiles = gg->GetMakefiles(); const auto& makefiles = gg->GetMakefiles();
if (!makefiles.empty()) { if (!makefiles.empty()) {
std::vector<std::string> const& configs = std::vector<std::string> const& configs =
makefiles[0]->GetGeneratorConfigs(); makefiles[0]->GetGeneratorConfigs();

4
Source/cmGhsMultiTargetGenerator.cxx
View File

@@ -279,10 +279,10 @@ void cmGhsMultiTargetGenerator::WriteTargetLinkLine(std::ostream& fout,
std::string frameworkPath; std::string frameworkPath;
std::string linkPath; std::string linkPath;
std::unique_ptr<cmLinkLineComputer> linkLineComputer( std::unique_ptr<cmLinkLineComputer> linkLineComputer =
this->GetGlobalGenerator()->CreateLinkLineComputer( this->GetGlobalGenerator()->CreateLinkLineComputer(
this->LocalGenerator, this->LocalGenerator,
this->LocalGenerator->GetStateSnapshot().GetDirectory())); this->LocalGenerator->GetStateSnapshot().GetDirectory());
this->LocalGenerator->GetTargetFlags( this->LocalGenerator->GetTargetFlags(
linkLineComputer.get(), config, linkLibraries, flags, linkFlags, linkLineComputer.get(), config, linkLibraries, flags, linkFlags,

71
Source/cmGlobalGenerator.cxx
View File

@@ -261,16 +261,17 @@ void cmGlobalGenerator::ResolveLanguageCompiler(const std::string& lang,
} }
} }
void cmGlobalGenerator::AddBuildExportSet(cmExportBuildFileGenerator* gen) void cmGlobalGenerator::AddBuildExportSet(
std::unique_ptr<cmExportBuildFileGenerator> gen)
{ {
this->BuildExportSets[gen->GetMainExportFileName()] = gen; this->BuildExportSets[gen->GetMainExportFileName()] = std::move(gen);
} }
void cmGlobalGenerator::AddBuildExportExportSet( void cmGlobalGenerator::AddBuildExportExportSet(
cmExportBuildFileGenerator* gen) std::unique_ptr<cmExportBuildFileGenerator> gen)
{ {
this->BuildExportSets[gen->GetMainExportFileName()] = gen; this->BuildExportExportSets[gen->GetMainExportFileName()] = gen.get();
this->BuildExportExportSets[gen->GetMainExportFileName()] = gen; this->AddBuildExportSet(std::move(gen));
} }
bool cmGlobalGenerator::GenerateImportFile(const std::string& file) bool cmGlobalGenerator::GenerateImportFile(const std::string& file)
@@ -280,13 +281,11 @@ bool cmGlobalGenerator::GenerateImportFile(const std::string& file)
bool result = it->second->GenerateImportFile(); bool result = it->second->GenerateImportFile();
if (!this->ConfigureDoneCMP0026AndCMP0024) { if (!this->ConfigureDoneCMP0026AndCMP0024) {
for (cmMakefile* m : this->Makefiles) { for (const auto& m : this->Makefiles) {
m->RemoveExportBuildFileGeneratorCMP0024(it->second); m->RemoveExportBuildFileGeneratorCMP0024(it->second.get());
} }
} }
delete it->second;
it->second = nullptr;
this->BuildExportSets.erase(it); this->BuildExportSets.erase(it);
return result; return result;
} }
@@ -1206,8 +1205,8 @@ void cmGlobalGenerator::CreateLocalGenerators()
this->LocalGeneratorSearchIndex.clear(); this->LocalGeneratorSearchIndex.clear();
this->LocalGenerators.clear(); this->LocalGenerators.clear();
this->LocalGenerators.reserve(this->Makefiles.size()); this->LocalGenerators.reserve(this->Makefiles.size());
for (cmMakefile* m : this->Makefiles) { for (const auto& m : this->Makefiles) {
auto lg = this->CreateLocalGenerator(m); auto lg = this->CreateLocalGenerator(m.get());
this->IndexLocalGenerator(lg.get()); this->IndexLocalGenerator(lg.get());
this->LocalGenerators.push_back(std::move(lg)); this->LocalGenerators.push_back(std::move(lg));
} }
@@ -1225,9 +1224,10 @@ void cmGlobalGenerator::Configure()
snapshot.GetDirectory().SetCurrentBinary( snapshot.GetDirectory().SetCurrentBinary(
this->CMakeInstance->GetHomeOutputDirectory()); this->CMakeInstance->GetHomeOutputDirectory());
cmMakefile* dirMf = new cmMakefile(this, snapshot); auto dirMfu = cm::make_unique<cmMakefile>(this, snapshot);
auto dirMf = dirMfu.get();
this->Makefiles.push_back(std::move(dirMfu));
dirMf->SetRecursionDepth(this->RecursionDepth); dirMf->SetRecursionDepth(this->RecursionDepth);
this->Makefiles.push_back(dirMf);
this->IndexMakefile(dirMf); this->IndexMakefile(dirMf);
this->BinaryDirectories.insert( this->BinaryDirectories.insert(
@@ -1245,11 +1245,11 @@ void cmGlobalGenerator::Configure()
std::vector<GlobalTargetInfo> globalTargets; std::vector<GlobalTargetInfo> globalTargets;
this->CreateDefaultGlobalTargets(globalTargets); this->CreateDefaultGlobalTargets(globalTargets);
for (cmMakefile* mf : this->Makefiles) { for (const auto& mf : this->Makefiles) {
auto& targets = mf->GetTargets(); auto& targets = mf->GetTargets();
for (GlobalTargetInfo const& globalTarget : globalTargets) { for (GlobalTargetInfo const& globalTarget : globalTargets) {
targets.emplace(globalTarget.Name, targets.emplace(globalTarget.Name,
this->CreateGlobalTarget(globalTarget, mf)); this->CreateGlobalTarget(globalTarget, mf.get()));
} }
} }
} }
@@ -1298,7 +1298,10 @@ void cmGlobalGenerator::CreateImportedGenerationObjects(
{ {
this->CreateGenerationObjects(ImportedOnly); this->CreateGenerationObjects(ImportedOnly);
auto const mfit = auto const mfit =
std::find(this->Makefiles.begin(), this->Makefiles.end(), mf); std::find_if(this->Makefiles.begin(), this->Makefiles.end(),
[mf](const std::unique_ptr<cmMakefile>& item) {
return item.get() == mf;
});
auto& lg = auto& lg =
this->LocalGenerators[std::distance(this->Makefiles.begin(), mfit)]; this->LocalGenerators[std::distance(this->Makefiles.begin(), mfit)];
for (std::string const& t : targets) { for (std::string const& t : targets) {
@@ -1313,7 +1316,7 @@ cmExportBuildFileGenerator* cmGlobalGenerator::GetExportedTargetsFile(
const std::string& filename) const const std::string& filename) const
{ {
auto const it = this->BuildExportSets.find(filename); auto const it = this->BuildExportSets.find(filename);
return it == this->BuildExportSets.end() ? nullptr : it->second; return it == this->BuildExportSets.end() ? nullptr : it->second.get();
} }
void cmGlobalGenerator::AddCMP0042WarnTarget(const std::string& target) void cmGlobalGenerator::AddCMP0042WarnTarget(const std::string& target)
@@ -1586,16 +1589,18 @@ bool cmGlobalGenerator::AddAutomaticSources()
return true; return true;
} }
cmLinkLineComputer* cmGlobalGenerator::CreateLinkLineComputer( std::unique_ptr<cmLinkLineComputer> cmGlobalGenerator::CreateLinkLineComputer(
cmOutputConverter* outputConverter, cmStateDirectory const& stateDir) const cmOutputConverter* outputConverter, cmStateDirectory const& stateDir) const
{ {
return new cmLinkLineComputer(outputConverter, stateDir); return cm::make_unique<cmLinkLineComputer>(outputConverter, stateDir);
} }
cmLinkLineComputer* cmGlobalGenerator::CreateMSVC60LinkLineComputer( std::unique_ptr<cmLinkLineComputer>
cmGlobalGenerator::CreateMSVC60LinkLineComputer(
cmOutputConverter* outputConverter, cmStateDirectory const& stateDir) const cmOutputConverter* outputConverter, cmStateDirectory const& stateDir) const
{ {
return new cmMSVC60LinkLineComputer(outputConverter, stateDir); return std::unique_ptr<cmLinkLineComputer>(
cm::make_unique<cmMSVC60LinkLineComputer>(outputConverter, stateDir));
} }
void cmGlobalGenerator::FinalizeTargetCompileInfo() void cmGlobalGenerator::FinalizeTargetCompileInfo()
@@ -1604,7 +1609,7 @@ void cmGlobalGenerator::FinalizeTargetCompileInfo()
this->CMakeInstance->GetState()->GetEnabledLanguages(); this->CMakeInstance->GetState()->GetEnabledLanguages();
// Construct per-target generator information. // Construct per-target generator information.
for (cmMakefile* mf : this->Makefiles) { for (const auto& mf : this->Makefiles) {
const cmStringRange noconfig_compile_definitions = const cmStringRange noconfig_compile_definitions =
mf->GetCompileDefinitionsEntries(); mf->GetCompileDefinitionsEntries();
const cmBacktraceRange noconfig_compile_definitions_bts = const cmBacktraceRange noconfig_compile_definitions_bts =
@@ -1681,7 +1686,7 @@ void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes)
{ {
std::map<cmTarget*, cmGeneratorTarget*> importedMap; std::map<cmTarget*, cmGeneratorTarget*> importedMap;
for (unsigned int i = 0; i < this->Makefiles.size(); ++i) { for (unsigned int i = 0; i < this->Makefiles.size(); ++i) {
cmMakefile* mf = this->Makefiles[i]; auto& mf = this->Makefiles[i];
for (cmTarget* ownedImpTgt : mf->GetOwnedImportedTargets()) { for (cmTarget* ownedImpTgt : mf->GetOwnedImportedTargets()) {
cmLocalGenerator* lg = this->LocalGenerators[i].get(); cmLocalGenerator* lg = this->LocalGenerators[i].get();
auto gt = cm::make_unique<cmGeneratorTarget>(ownedImpTgt, lg); auto gt = cm::make_unique<cmGeneratorTarget>(ownedImpTgt, lg);
@@ -1692,17 +1697,15 @@ void cmGlobalGenerator::CreateGeneratorTargets(TargetTypes targetTypes)
// Construct per-target generator information. // Construct per-target generator information.
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) { for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i) {
this->CreateGeneratorTargets(targetTypes, this->Makefiles[i], this->CreateGeneratorTargets(targetTypes, this->Makefiles[i].get(),
this->LocalGenerators[i].get(), importedMap); this->LocalGenerators[i].get(), importedMap);
} }
} }
void cmGlobalGenerator::ClearGeneratorMembers() void cmGlobalGenerator::ClearGeneratorMembers()
{ {
cmDeleteAll(this->BuildExportSets);
this->BuildExportSets.clear(); this->BuildExportSets.clear();
cmDeleteAll(this->Makefiles);
this->Makefiles.clear(); this->Makefiles.clear();
this->LocalGenerators.clear(); this->LocalGenerators.clear();
@@ -1999,10 +2002,10 @@ std::string cmGlobalGenerator::GenerateCMakeBuildCommand(
return makeCommand; return makeCommand;
} }
void cmGlobalGenerator::AddMakefile(cmMakefile* mf) void cmGlobalGenerator::AddMakefile(std::unique_ptr<cmMakefile> mf)
{ {
this->Makefiles.push_back(mf); this->IndexMakefile(mf.get());
this->IndexMakefile(mf); this->Makefiles.push_back(std::move(mf));
// update progress // update progress
// estimate how many lg there will be // estimate how many lg there will be
@@ -2354,7 +2357,7 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(
void cmGlobalGenerator::AddGlobalTarget_Package( void cmGlobalGenerator::AddGlobalTarget_Package(
std::vector<GlobalTargetInfo>& targets) std::vector<GlobalTargetInfo>& targets)
{ {
cmMakefile* mf = this->Makefiles[0]; auto& mf = this->Makefiles[0];
std::string configFile = std::string configFile =
cmStrCat(mf->GetCurrentBinaryDirectory(), "/CPackConfig.cmake"); cmStrCat(mf->GetCurrentBinaryDirectory(), "/CPackConfig.cmake");
if (!cmSystemTools::FileExists(configFile)) { if (!cmSystemTools::FileExists(configFile)) {
@@ -2403,7 +2406,7 @@ void cmGlobalGenerator::AddGlobalTarget_PackageSource(
return; return;
} }
cmMakefile* mf = this->Makefiles[0]; auto& mf = this->Makefiles[0];
std::string configFile = std::string configFile =
cmStrCat(mf->GetCurrentBinaryDirectory(), "/CPackSourceConfig.cmake"); cmStrCat(mf->GetCurrentBinaryDirectory(), "/CPackSourceConfig.cmake");
if (!cmSystemTools::FileExists(configFile)) { if (!cmSystemTools::FileExists(configFile)) {
@@ -2435,7 +2438,7 @@ void cmGlobalGenerator::AddGlobalTarget_PackageSource(
void cmGlobalGenerator::AddGlobalTarget_Test( void cmGlobalGenerator::AddGlobalTarget_Test(
std::vector<GlobalTargetInfo>& targets) std::vector<GlobalTargetInfo>& targets)
{ {
cmMakefile* mf = this->Makefiles[0]; auto& mf = this->Makefiles[0];
if (!mf->IsOn("CMAKE_TESTING_ENABLED")) { if (!mf->IsOn("CMAKE_TESTING_ENABLED")) {
return; return;
} }
@@ -2523,7 +2526,7 @@ void cmGlobalGenerator::AddGlobalTarget_RebuildCache(
void cmGlobalGenerator::AddGlobalTarget_Install( void cmGlobalGenerator::AddGlobalTarget_Install(
std::vector<GlobalTargetInfo>& targets) std::vector<GlobalTargetInfo>& targets)
{ {
cmMakefile* mf = this->Makefiles[0]; auto& mf = this->Makefiles[0];
const char* cmakeCfgIntDir = this->GetCMakeCFGIntDir(); const char* cmakeCfgIntDir = this->GetCMakeCFGIntDir();
bool skipInstallRules = mf->IsOn("CMAKE_SKIP_INSTALL_RULES"); bool skipInstallRules = mf->IsOn("CMAKE_SKIP_INSTALL_RULES");
if (this->InstallTargetEnabled && skipInstallRules) { if (this->InstallTargetEnabled && skipInstallRules) {
@@ -2573,7 +2576,7 @@ void cmGlobalGenerator::AddGlobalTarget_Install(
singleLine.push_back(cmd); singleLine.push_back(cmd);
if (cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.') { if (cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.') {
std::string cfgArg = "-DBUILD_TYPE="; std::string cfgArg = "-DBUILD_TYPE=";
bool useEPN = this->UseEffectivePlatformName(mf); bool useEPN = this->UseEffectivePlatformName(mf.get());
if (useEPN) { if (useEPN) {
cfgArg += "$(CONFIGURATION)"; cfgArg += "$(CONFIGURATION)";
singleLine.push_back(cfgArg); singleLine.push_back(cfgArg);

20
Source/cmGlobalGenerator.h
View File

@@ -162,11 +162,11 @@ public:
*/ */
virtual void Generate(); virtual void Generate();
virtual cmLinkLineComputer* CreateLinkLineComputer( virtual std::unique_ptr<cmLinkLineComputer> CreateLinkLineComputer(
cmOutputConverter* outputConverter, cmOutputConverter* outputConverter,
cmStateDirectory const& stateDir) const; cmStateDirectory const& stateDir) const;
cmLinkLineComputer* CreateMSVC60LinkLineComputer( std::unique_ptr<cmLinkLineComputer> CreateMSVC60LinkLineComputer(
cmOutputConverter* outputConverter, cmOutputConverter* outputConverter,
cmStateDirectory const& stateDir) const; cmStateDirectory const& stateDir) const;
@@ -249,7 +249,7 @@ public:
cmake* GetCMakeInstance() const { return this->CMakeInstance; } cmake* GetCMakeInstance() const { return this->CMakeInstance; }
void SetConfiguredFilesPath(cmGlobalGenerator* gen); void SetConfiguredFilesPath(cmGlobalGenerator* gen);
const std::vector<cmMakefile*>& GetMakefiles() const const std::vector<std::unique_ptr<cmMakefile>>& GetMakefiles() const
{ {
return this->Makefiles; return this->Makefiles;
} }
@@ -268,7 +268,7 @@ public:
this->CurrentConfigureMakefile = mf; this->CurrentConfigureMakefile = mf;
} }
void AddMakefile(cmMakefile* mf); void AddMakefile(std::unique_ptr<cmMakefile> mf);
//! Set an generator for an "external makefile based project" //! Set an generator for an "external makefile based project"
void SetExternalMakefileProjectGenerator( void SetExternalMakefileProjectGenerator(
@@ -445,12 +445,13 @@ public:
void ProcessEvaluationFiles(); void ProcessEvaluationFiles();
std::map<std::string, cmExportBuildFileGenerator*>& GetBuildExportSets() std::map<std::string, std::unique_ptr<cmExportBuildFileGenerator>>&
GetBuildExportSets()
{ {
return this->BuildExportSets; return this->BuildExportSets;
} }
void AddBuildExportSet(cmExportBuildFileGenerator*); void AddBuildExportSet(std::unique_ptr<cmExportBuildFileGenerator>);
void AddBuildExportExportSet(cmExportBuildFileGenerator*); void AddBuildExportExportSet(std::unique_ptr<cmExportBuildFileGenerator>);
bool IsExportedTargetsFile(const std::string& filename) const; bool IsExportedTargetsFile(const std::string& filename) const;
bool GenerateImportFile(const std::string& file); bool GenerateImportFile(const std::string& file);
cmExportBuildFileGenerator* GetExportedTargetsFile( cmExportBuildFileGenerator* GetExportedTargetsFile(
@@ -549,7 +550,7 @@ protected:
std::string FindMakeProgramFile; std::string FindMakeProgramFile;
std::string ConfiguredFilesPath; std::string ConfiguredFilesPath;
cmake* CMakeInstance; cmake* CMakeInstance;
std::vector<cmMakefile*> Makefiles; std::vector<std::unique_ptr<cmMakefile>> Makefiles;
LocalGeneratorVector LocalGenerators; LocalGeneratorVector LocalGenerators;
cmMakefile* CurrentConfigureMakefile; cmMakefile* CurrentConfigureMakefile;
// map from project name to vector of local generators in that project // map from project name to vector of local generators in that project
@@ -559,7 +560,8 @@ protected:
std::set<std::string> InstallComponents; std::set<std::string> InstallComponents;
// Sets of named target exports // Sets of named target exports
cmExportSetMap ExportSets; cmExportSetMap ExportSets;
std::map<std::string, cmExportBuildFileGenerator*> BuildExportSets; std::map<std::string, std::unique_ptr<cmExportBuildFileGenerator>>
BuildExportSets;
std::map<std::string, cmExportBuildFileGenerator*> BuildExportExportSets; std::map<std::string, cmExportBuildFileGenerator*> BuildExportExportSets;
std::map<std::string, std::string> AliasTargets; std::map<std::string, std::string> AliasTargets;

15
Source/cmGlobalNinjaGenerator.cxx
View File

@@ -25,6 +25,7 @@
#include "cmGeneratorExpressionEvaluationFile.h" #include "cmGeneratorExpressionEvaluationFile.h"
#include "cmGeneratorTarget.h" #include "cmGeneratorTarget.h"
#include "cmGlobalGenerator.h" #include "cmGlobalGenerator.h"
#include "cmLinkLineComputer.h"
#include "cmListFileCache.h" #include "cmListFileCache.h"
#include "cmLocalGenerator.h" #include "cmLocalGenerator.h"
#include "cmLocalNinjaGenerator.h" #include "cmLocalNinjaGenerator.h"
@@ -44,8 +45,6 @@
#include "cmVersion.h" #include "cmVersion.h"
#include "cmake.h" #include "cmake.h"
class cmLinkLineComputer;
const char* cmGlobalNinjaGenerator::NINJA_BUILD_FILE = "build.ninja"; const char* cmGlobalNinjaGenerator::NINJA_BUILD_FILE = "build.ninja";
const char* cmGlobalNinjaGenerator::NINJA_RULES_FILE = "rules.ninja"; const char* cmGlobalNinjaGenerator::NINJA_RULES_FILE = "rules.ninja";
const char* cmGlobalNinjaGenerator::INDENT = " "; const char* cmGlobalNinjaGenerator::INDENT = " ";
@@ -85,13 +84,15 @@ void cmGlobalNinjaGenerator::WriteComment(std::ostream& os,
os << "# " << comment.substr(lpos) << "\n\n"; os << "# " << comment.substr(lpos) << "\n\n";
} }
cmLinkLineComputer* cmGlobalNinjaGenerator::CreateLinkLineComputer( std::unique_ptr<cmLinkLineComputer>
cmGlobalNinjaGenerator::CreateLinkLineComputer(
cmOutputConverter* outputConverter, cmOutputConverter* outputConverter,
cmStateDirectory const& /* stateDir */) const cmStateDirectory const& /* stateDir */) const
{ {
return new cmNinjaLinkLineComputer( return std::unique_ptr<cmLinkLineComputer>(
outputConverter, cm::make_unique<cmNinjaLinkLineComputer>(
this->LocalGenerators[0]->GetStateSnapshot().GetDirectory(), this); outputConverter,
this->LocalGenerators[0]->GetStateSnapshot().GetDirectory(), this));
} }
std::string cmGlobalNinjaGenerator::EncodeRuleName(std::string const& name) std::string cmGlobalNinjaGenerator::EncodeRuleName(std::string const& name)
@@ -2044,7 +2045,7 @@ bool cmGlobalNinjaGenerator::WriteDyndepFile(
snapshot.GetDirectory().SetRelativePathTopBinary(dir_top_bld.c_str()); snapshot.GetDirectory().SetRelativePathTopBinary(dir_top_bld.c_str());
auto mfd = cm::make_unique<cmMakefile>(this, snapshot); auto mfd = cm::make_unique<cmMakefile>(this, snapshot);
auto lgd = this->CreateLocalGenerator(mfd.get()); auto lgd = this->CreateLocalGenerator(mfd.get());
this->Makefiles.push_back(mfd.release()); this->Makefiles.push_back(std::move(mfd));
this->LocalGenerators.push_back(std::move(lgd)); this->LocalGenerators.push_back(std::move(lgd));
} }

2
Source/cmGlobalNinjaGenerator.h
View File

@@ -77,7 +77,7 @@ public:
std::string EncodeLiteral(const std::string& lit); std::string EncodeLiteral(const std::string& lit);
std::string EncodePath(const std::string& path); std::string EncodePath(const std::string& path);
cmLinkLineComputer* CreateLinkLineComputer( std::unique_ptr<cmLinkLineComputer> CreateLinkLineComputer(
cmOutputConverter* outputConverter, cmOutputConverter* outputConverter,
cmStateDirectory const& stateDir) const override; cmStateDirectory const& stateDir) const override;

2
Source/cmGlobalUnixMakefileGenerator3.cxx
View File

@@ -492,7 +492,7 @@ cmGlobalUnixMakefileGenerator3::GenerateBuildCommand(
std::unique_ptr<cmMakefile> mfu; std::unique_ptr<cmMakefile> mfu;
cmMakefile* mf; cmMakefile* mf;
if (!this->Makefiles.empty()) { if (!this->Makefiles.empty()) {
mf = this->Makefiles[0]; mf = this->Makefiles[0].get();
} else { } else {
cmStateSnapshot snapshot = this->CMakeInstance->GetCurrentSnapshot(); cmStateSnapshot snapshot = this->CMakeInstance->GetCurrentSnapshot();
snapshot.GetDirectory().SetCurrentSource( snapshot.GetDirectory().SetCurrentSource(

7
Source/cmJsonObjects.cxx
View File

@@ -8,6 +8,7 @@
#include <functional> #include <functional>
#include <limits> #include <limits>
#include <map> #include <map>
#include <memory>
#include <set> #include <set>
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
@@ -44,7 +45,7 @@ namespace {
std::vector<std::string> getConfigurations(const cmake* cm) std::vector<std::string> getConfigurations(const cmake* cm)
{ {
std::vector<std::string> configurations; std::vector<std::string> configurations;
auto makefiles = cm->GetGlobalGenerator()->GetMakefiles(); const auto& makefiles = cm->GetGlobalGenerator()->GetMakefiles();
if (makefiles.empty()) { if (makefiles.empty()) {
return configurations; return configurations;
} }
@@ -83,8 +84,8 @@ void cmGetCMakeInputs(const cmGlobalGenerator* gg,
std::vector<std::string>* tmpFiles) std::vector<std::string>* tmpFiles)
{ {
const std::string cmakeRootDir = cmSystemTools::GetCMakeRoot() + '/'; const std::string cmakeRootDir = cmSystemTools::GetCMakeRoot() + '/';
std::vector<cmMakefile*> const& makefiles = gg->GetMakefiles(); auto const& makefiles = gg->GetMakefiles();
for (cmMakefile const* mf : makefiles) { for (const auto& mf : makefiles) {
for (std::string const& lf : mf->GetListFiles()) { for (std::string const& lf : mf->GetListFiles()) {
const std::string startOfFile = lf.substr(0, cmakeRootDir.size()); const std::string startOfFile = lf.substr(0, cmakeRootDir.size());

7
Source/cmMakefile.cxx
View File

@@ -15,6 +15,7 @@
#include <utility> #include <utility>
#include <cm/iterator> #include <cm/iterator>
#include <cm/memory>
#include <cm/optional> #include <cm/optional>
#include <cmext/algorithm> #include <cmext/algorithm>
@@ -1723,8 +1724,10 @@ void cmMakefile::AddSubDirectory(const std::string& srcPath,
cmSystemTools::MakeDirectory(binPath); cmSystemTools::MakeDirectory(binPath);
cmMakefile* subMf = new cmMakefile(this->GlobalGenerator, newSnapshot); auto subMfu =
this->GetGlobalGenerator()->AddMakefile(subMf); cm::make_unique<cmMakefile>(this->GlobalGenerator, newSnapshot);
auto subMf = subMfu.get();
this->GetGlobalGenerator()->AddMakefile(std::move(subMfu));
if (excludeFromAll) { if (excludeFromAll) {
subMf->SetProperty("EXCLUDE_FROM_ALL", "TRUE"); subMf->SetProperty("EXCLUDE_FROM_ALL", "TRUE");

8
Source/cmMakefileExecutableTargetGenerator.cxx
View File

@@ -420,10 +420,10 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
this->GetTargetLinkFlags(linkFlags, linkLanguage); this->GetTargetLinkFlags(linkFlags, linkLanguage);
{ {
std::unique_ptr<cmLinkLineComputer> linkLineComputer( std::unique_ptr<cmLinkLineComputer> linkLineComputer =
this->CreateLinkLineComputer( this->CreateLinkLineComputer(
this->LocalGenerator, this->LocalGenerator,
this->LocalGenerator->GetStateSnapshot().GetDirectory())); this->LocalGenerator->GetStateSnapshot().GetDirectory());
this->AddModuleDefinitionFlag(linkLineComputer.get(), linkFlags, this->AddModuleDefinitionFlag(linkLineComputer.get(), linkFlags,
this->GetConfigName()); this->GetConfigName());
@@ -509,10 +509,10 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
// Set path conversion for link script shells. // Set path conversion for link script shells.
this->LocalGenerator->SetLinkScriptShell(useLinkScript); this->LocalGenerator->SetLinkScriptShell(useLinkScript);
std::unique_ptr<cmLinkLineComputer> linkLineComputer( std::unique_ptr<cmLinkLineComputer> linkLineComputer =
this->CreateLinkLineComputer( this->CreateLinkLineComputer(
this->LocalGenerator, this->LocalGenerator,
this->LocalGenerator->GetStateSnapshot().GetDirectory())); this->LocalGenerator->GetStateSnapshot().GetDirectory());
linkLineComputer->SetForResponse(useResponseFileForLibs); linkLineComputer->SetForResponse(useResponseFileForLibs);
linkLineComputer->SetUseWatcomQuote(useWatcomQuote); linkLineComputer->SetUseWatcomQuote(useWatcomQuote);
linkLineComputer->SetRelink(relink); linkLineComputer->SetRelink(relink);

12
Source/cmMakefileLibraryTargetGenerator.cxx
View File

@@ -172,10 +172,10 @@ void cmMakefileLibraryTargetGenerator::WriteSharedLibraryRules(bool relink)
this->LocalGenerator->AddConfigVariableFlags( this->LocalGenerator->AddConfigVariableFlags(
extraFlags, "CMAKE_SHARED_LINKER_FLAGS", this->GetConfigName()); extraFlags, "CMAKE_SHARED_LINKER_FLAGS", this->GetConfigName());
std::unique_ptr<cmLinkLineComputer> linkLineComputer( std::unique_ptr<cmLinkLineComputer> linkLineComputer =
this->CreateLinkLineComputer( this->CreateLinkLineComputer(
this->LocalGenerator, this->LocalGenerator,
this->LocalGenerator->GetStateSnapshot().GetDirectory())); this->LocalGenerator->GetStateSnapshot().GetDirectory());
this->AddModuleDefinitionFlag(linkLineComputer.get(), extraFlags, this->AddModuleDefinitionFlag(linkLineComputer.get(), extraFlags,
this->GetConfigName()); this->GetConfigName());
@@ -207,10 +207,10 @@ void cmMakefileLibraryTargetGenerator::WriteModuleLibraryRules(bool relink)
this->LocalGenerator->AddConfigVariableFlags( this->LocalGenerator->AddConfigVariableFlags(
extraFlags, "CMAKE_MODULE_LINKER_FLAGS", this->GetConfigName()); extraFlags, "CMAKE_MODULE_LINKER_FLAGS", this->GetConfigName());
std::unique_ptr<cmLinkLineComputer> linkLineComputer( std::unique_ptr<cmLinkLineComputer> linkLineComputer =
this->CreateLinkLineComputer( this->CreateLinkLineComputer(
this->LocalGenerator, this->LocalGenerator,
this->LocalGenerator->GetStateSnapshot().GetDirectory())); this->LocalGenerator->GetStateSnapshot().GetDirectory());
this->AddModuleDefinitionFlag(linkLineComputer.get(), extraFlags, this->AddModuleDefinitionFlag(linkLineComputer.get(), extraFlags,
this->GetConfigName()); this->GetConfigName());
@@ -700,10 +700,10 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
std::string linkLibs; std::string linkLibs;
if (this->GeneratorTarget->GetType() != cmStateEnums::STATIC_LIBRARY) { if (this->GeneratorTarget->GetType() != cmStateEnums::STATIC_LIBRARY) {
std::unique_ptr<cmLinkLineComputer> linkLineComputer( std::unique_ptr<cmLinkLineComputer> linkLineComputer =
this->CreateLinkLineComputer( this->CreateLinkLineComputer(
this->LocalGenerator, this->LocalGenerator,
this->LocalGenerator->GetStateSnapshot().GetDirectory())); this->LocalGenerator->GetStateSnapshot().GetDirectory());
linkLineComputer->SetForResponse(useResponseFileForLibs); linkLineComputer->SetForResponse(useResponseFileForLibs);
linkLineComputer->SetUseWatcomQuote(useWatcomQuote); linkLineComputer->SetUseWatcomQuote(useWatcomQuote);
linkLineComputer->SetRelink(relink); linkLineComputer->SetRelink(relink);

4
Source/cmMakefileTargetGenerator.cxx
View File

@@ -17,6 +17,7 @@
#include "cmGeneratorExpression.h" #include "cmGeneratorExpression.h"
#include "cmGeneratorTarget.h" #include "cmGeneratorTarget.h"
#include "cmGlobalUnixMakefileGenerator3.h" #include "cmGlobalUnixMakefileGenerator3.h"
#include "cmLinkLineComputer.h"
#include "cmLocalCommonGenerator.h" #include "cmLocalCommonGenerator.h"
#include "cmLocalUnixMakefileGenerator3.h" #include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h" #include "cmMakefile.h"
@@ -1634,7 +1635,8 @@ std::string cmMakefileTargetGenerator::CreateResponseFile(
return responseFileName; return responseFileName;
} }
cmLinkLineComputer* cmMakefileTargetGenerator::CreateLinkLineComputer( std::unique_ptr<cmLinkLineComputer>
cmMakefileTargetGenerator::CreateLinkLineComputer(
cmOutputConverter* outputConverter, cmStateDirectory const& stateDir) cmOutputConverter* outputConverter, cmStateDirectory const& stateDir)
{ {
if (this->Makefile->IsOn("MSVC60")) { if (this->Makefile->IsOn("MSVC60")) {

2
Source/cmMakefileTargetGenerator.h
View File

@@ -140,7 +140,7 @@ protected:
std::vector<std::string>& makefile_commands, std::vector<std::string>& makefile_commands,
std::vector<std::string>& makefile_depends); std::vector<std::string>& makefile_depends);
cmLinkLineComputer* CreateLinkLineComputer( std::unique_ptr<cmLinkLineComputer> CreateLinkLineComputer(
cmOutputConverter* outputConverter, cmStateDirectory const& stateDir); cmOutputConverter* outputConverter, cmStateDirectory const& stateDir);
/** Create a response file with the given set of options. Returns /** Create a response file with the given set of options. Returns

4
Source/cmNinjaNormalTargetGenerator.cxx
View File

@@ -884,10 +884,10 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement(
vars["TARGET_FILE"] = vars["TARGET_FILE"] =
localGen.ConvertToOutputFormat(targetOutputReal, cmOutputConverter::SHELL); localGen.ConvertToOutputFormat(targetOutputReal, cmOutputConverter::SHELL);
std::unique_ptr<cmLinkLineComputer> linkLineComputer( std::unique_ptr<cmLinkLineComputer> linkLineComputer =
globalGen->CreateLinkLineComputer( globalGen->CreateLinkLineComputer(
this->GetLocalGenerator(), this->GetLocalGenerator(),
this->GetLocalGenerator()->GetStateSnapshot().GetDirectory())); this->GetLocalGenerator()->GetStateSnapshot().GetDirectory());
linkLineComputer->SetUseWatcomQuote(useWatcomQuote); linkLineComputer->SetUseWatcomQuote(useWatcomQuote);
linkLineComputer->SetUseNinjaMulti(globalGen->IsMultiConfig()); linkLineComputer->SetUseNinjaMulti(globalGen->IsMultiConfig());

33
Source/cmake.cxx
View File

@@ -2,6 +2,15 @@
file Copyright.txt or https://cmake.org/licensing for details. */ file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmake.h" #include "cmake.h"
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <initializer_list>
#include <iostream>
#include <sstream>
#include <utility>
#include <cm/memory> #include <cm/memory>
#include <cm/string_view> #include <cm/string_view>
#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(CMAKE_BOOT_MINGW) #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(CMAKE_BOOT_MINGW)
@@ -10,6 +19,10 @@
#include <cmext/algorithm> #include <cmext/algorithm>
#include "cmsys/FStream.hxx"
#include "cmsys/Glob.hxx"
#include "cmsys/RegularExpression.hxx"
#include "cm_sys_stat.h" #include "cm_sys_stat.h"
#include "cmAlgorithms.h" #include "cmAlgorithms.h"
@@ -108,19 +121,6 @@
# include <sys/time.h> # include <sys/time.h>
#endif #endif
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <initializer_list>
#include <iostream>
#include <sstream>
#include <utility>
#include "cmsys/FStream.hxx"
#include "cmsys/Glob.hxx"
#include "cmsys/RegularExpression.hxx"
namespace { namespace {
#if !defined(CMAKE_BOOTSTRAP) #if !defined(CMAKE_BOOTSTRAP)
@@ -513,8 +513,9 @@ bool cmake::FindPackage(const std::vector<std::string>& args)
cmSystemTools::GetCurrentWorkingDirectory()); cmSystemTools::GetCurrentWorkingDirectory());
// read in the list file to fill the cache // read in the list file to fill the cache
snapshot.SetDefaultDefinitions(); snapshot.SetDefaultDefinitions();
cmMakefile* mf = new cmMakefile(gg, snapshot); auto mfu = cm::make_unique<cmMakefile>(gg, snapshot);
gg->AddMakefile(mf); cmMakefile* mf = mfu.get();
gg->AddMakefile(std::move(mfu));
mf->SetArgcArgv(args); mf->SetArgcArgv(args);
@@ -1647,7 +1648,7 @@ int cmake::ActualConfigure()
} }
} }
cmMakefile* mf = this->GlobalGenerator->GetMakefiles()[0]; auto& mf = this->GlobalGenerator->GetMakefiles()[0];
if (mf->IsOn("CTEST_USE_LAUNCHERS") && if (mf->IsOn("CTEST_USE_LAUNCHERS") &&
!this->State->GetGlobalProperty("RULE_LAUNCH_COMPILE")) { !this->State->GetGlobalProperty("RULE_LAUNCH_COMPILE")) {
cmSystemTools::Error( cmSystemTools::Error(