[Cmake-commits] CMake branch, master, updated. v3.15.0-rc4-306-gd7e53b4
Kitware Robot
kwrobot at kitware.com
Mon Jul 15 07:43:07 EDT 2019
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "CMake".
The branch, master has been updated
via d7e53b427428bc23778d1b094e8893df4573e22e (commit)
via a92b7fd46bcf1ecd255290d84c691a244c8ecb26 (commit)
via 3376067bae3972b0fc7232b524ee80e2fc39950f (commit)
via 5133cab1922ec68446b47eee8e1baa8c3eaa446f (commit)
via 0964a969728e416b2abbedf41517c46e5cf2cb1c (commit)
via 1591f138f1a40fccdde7fb2796ee2d2d8f3f97bb (commit)
via d9b2c7dae242868f13fc366773fb09448da26e8d (commit)
via 7ff9ab3b101b131bd4a91a459f66ce27f97f4757 (commit)
via 79f5ef19fe418efe2d9bfc55fcd16dfd75f18d49 (commit)
via 22d3eb5d5e4ce9c6371ab709655928552453fbda (commit)
via 7242d812691e95cae578a597161693940447b38c (commit)
via 3af48083a24676025590e1e3a8db2cfef0317901 (commit)
via f84d2045e916a3656e3c72f8be268c4a0c9f4dcc (commit)
from 1b8fdad269711da81a4f93526247e14057d7c0c7 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=d7e53b427428bc23778d1b094e8893df4573e22e
commit d7e53b427428bc23778d1b094e8893df4573e22e
Merge: a92b7fd 7ff9ab3
Author: Brad King <brad.king at kitware.com>
AuthorDate: Mon Jul 15 11:41:43 2019 +0000
Commit: Kitware Robot <kwrobot at kitware.com>
CommitDate: Mon Jul 15 07:41:52 2019 -0400
Merge topic 'cleanup-gen-lookups'
7ff9ab3b10 Makefile: De-duplicate executable link rule lookup
79f5ef19fe De-duplicate checks for whether a platform uses Windows DLLs
22d3eb5d5e Refactor checks for whether a target has an import library
Acked-by: Kitware Robot <kwrobot at kitware.com>
Merge-request: !3550
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=a92b7fd46bcf1ecd255290d84c691a244c8ecb26
commit a92b7fd46bcf1ecd255290d84c691a244c8ecb26
Merge: 3376067 1591f13
Author: Brad King <brad.king at kitware.com>
AuthorDate: Mon Jul 15 11:39:47 2019 +0000
Commit: Kitware Robot <kwrobot at kitware.com>
CommitDate: Mon Jul 15 07:40:00 2019 -0400
Merge topic 'modernize-cmCommand-memory-management'
1591f138f1 modernize: manage cmCommand instances using unique_ptr.
d9b2c7dae2 Introduce memory management helper: cm_memory.hxx
Acked-by: Kitware Robot <kwrobot at kitware.com>
Acked-by: Sebastian Holtermann <sebholt at web.de>
Merge-request: !3513
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=3376067bae3972b0fc7232b524ee80e2fc39950f
commit 3376067bae3972b0fc7232b524ee80e2fc39950f
Merge: 5133cab 7242d81
Author: Brad King <brad.king at kitware.com>
AuthorDate: Mon Jul 15 07:35:17 2019 -0400
Commit: Brad King <brad.king at kitware.com>
CommitDate: Mon Jul 15 07:35:17 2019 -0400
Merge branch 'release-3.15'
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=5133cab1922ec68446b47eee8e1baa8c3eaa446f
commit 5133cab1922ec68446b47eee8e1baa8c3eaa446f
Merge: 0964a96 3af4808
Author: Brad King <brad.king at kitware.com>
AuthorDate: Mon Jul 15 07:34:54 2019 -0400
Commit: Brad King <brad.king at kitware.com>
CommitDate: Mon Jul 15 07:34:54 2019 -0400
Merge branch 'release-3.14'
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=0964a969728e416b2abbedf41517c46e5cf2cb1c
commit 0964a969728e416b2abbedf41517c46e5cf2cb1c
Merge: 1b8fdad f84d204
Author: Brad King <brad.king at kitware.com>
AuthorDate: Mon Jul 15 11:33:52 2019 +0000
Commit: Kitware Robot <kwrobot at kitware.com>
CommitDate: Mon Jul 15 07:34:01 2019 -0400
Merge topic 'FindBISON-CMP0088-SourcePath'
f84d2045e9 FindBISON: Fix CMP0088 NEW behavior for non-absolute input paths
Acked-by: Kitware Robot <kwrobot at kitware.com>
Merge-request: !3549
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=1591f138f1a40fccdde7fb2796ee2d2d8f3f97bb
commit 1591f138f1a40fccdde7fb2796ee2d2d8f3f97bb
Author: Marc Chevrier <marc.chevrier at gmail.com>
AuthorDate: Thu Jul 4 18:14:22 2019 +0200
Commit: Marc Chevrier <marc.chevrier at gmail.com>
CommitDate: Sun Jul 14 15:37:30 2019 +0200
modernize: manage cmCommand instances using unique_ptr.
diff --git a/Source/CTest/cmCTestBuildCommand.h b/Source/CTest/cmCTestBuildCommand.h
index 77b0549..a62c301 100644
--- a/Source/CTest/cmCTestBuildCommand.h
+++ b/Source/CTest/cmCTestBuildCommand.h
@@ -6,13 +6,16 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include "cmCTestHandlerCommand.h"
+#include "cmCommand.h"
#include <string>
+#include <utility>
#include <vector>
+#include "cm_memory.hxx"
+
class cmCTestBuildHandler;
class cmCTestGenericHandler;
-class cmCommand;
class cmExecutionStatus;
class cmGlobalGenerator;
@@ -30,12 +33,12 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestBuildCommand* ni = new cmCTestBuildCommand;
+ auto ni = cm::make_unique<cmCTestBuildCommand>();
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
- return ni;
+ return std::unique_ptr<cmCommand>(std::move(ni));
}
/**
diff --git a/Source/CTest/cmCTestConfigureCommand.h b/Source/CTest/cmCTestConfigureCommand.h
index 0cbcbfa..4677c83 100644
--- a/Source/CTest/cmCTestConfigureCommand.h
+++ b/Source/CTest/cmCTestConfigureCommand.h
@@ -6,11 +6,14 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include "cmCTestHandlerCommand.h"
+#include "cmCommand.h"
#include <string>
+#include <utility>
+
+#include "cm_memory.hxx"
class cmCTestGenericHandler;
-class cmCommand;
/** \class cmCTestConfigure
* \brief Run a ctest script
@@ -25,12 +28,12 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestConfigureCommand* ni = new cmCTestConfigureCommand;
+ auto ni = cm::make_unique<cmCTestConfigureCommand>();
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
- return ni;
+ return std::unique_ptr<cmCommand>(std::move(ni));
}
/**
diff --git a/Source/CTest/cmCTestCoverageCommand.h b/Source/CTest/cmCTestCoverageCommand.h
index 1ae2d86..08f31f7 100644
--- a/Source/CTest/cmCTestCoverageCommand.h
+++ b/Source/CTest/cmCTestCoverageCommand.h
@@ -6,12 +6,15 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include "cmCTestHandlerCommand.h"
+#include "cmCommand.h"
#include <set>
#include <string>
+#include <utility>
+
+#include "cm_memory.hxx"
class cmCTestGenericHandler;
-class cmCommand;
/** \class cmCTestCoverage
* \brief Run a ctest script
@@ -26,12 +29,12 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestCoverageCommand* ni = new cmCTestCoverageCommand;
+ auto ni = cm::make_unique<cmCTestCoverageCommand>();
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
- return ni;
+ return std::unique_ptr<cmCommand>(std::move(ni));
}
/**
diff --git a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
index 9425ece..84250cb 100644
--- a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
+++ b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
@@ -6,11 +6,14 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include "cmCTestCommand.h"
+#include "cmCommand.h"
#include <string>
+#include <utility>
#include <vector>
-class cmCommand;
+#include "cm_memory.hxx"
+
class cmExecutionStatus;
/** \class cmCTestEmptyBinaryDirectory
@@ -27,13 +30,12 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestEmptyBinaryDirectoryCommand* ni =
- new cmCTestEmptyBinaryDirectoryCommand;
+ auto ni = cm::make_unique<cmCTestEmptyBinaryDirectoryCommand>();
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
- return ni;
+ return std::unique_ptr<cmCommand>(std::move(ni));
}
/**
diff --git a/Source/CTest/cmCTestMemCheckCommand.h b/Source/CTest/cmCTestMemCheckCommand.h
index b6b3c40..837a687 100644
--- a/Source/CTest/cmCTestMemCheckCommand.h
+++ b/Source/CTest/cmCTestMemCheckCommand.h
@@ -5,10 +5,14 @@
#include "cmConfigure.h" // IWYU pragma: keep
+#include <utility>
+
+#include "cm_memory.hxx"
+
#include "cmCTestTestCommand.h"
+#include "cmCommand.h"
class cmCTestGenericHandler;
-class cmCommand;
/** \class cmCTestMemCheck
* \brief Run a ctest script
@@ -23,12 +27,12 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestMemCheckCommand* ni = new cmCTestMemCheckCommand;
+ auto ni = cm::make_unique<cmCTestMemCheckCommand>();
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
- return ni;
+ return std::unique_ptr<cmCommand>(std::move(ni));
}
protected:
diff --git a/Source/CTest/cmCTestReadCustomFilesCommand.h b/Source/CTest/cmCTestReadCustomFilesCommand.h
index ba25c51..db2ac5e 100644
--- a/Source/CTest/cmCTestReadCustomFilesCommand.h
+++ b/Source/CTest/cmCTestReadCustomFilesCommand.h
@@ -6,11 +6,14 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include "cmCTestCommand.h"
+#include "cmCommand.h"
#include <string>
+#include <utility>
#include <vector>
-class cmCommand;
+#include "cm_memory.hxx"
+
class cmExecutionStatus;
/** \class cmCTestReadCustomFiles
@@ -27,11 +30,11 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestReadCustomFilesCommand* ni = new cmCTestReadCustomFilesCommand;
+ auto ni = cm::make_unique<cmCTestReadCustomFilesCommand>();
ni->CTest = this->CTest;
- return ni;
+ return std::unique_ptr<cmCommand>(std::move(ni));
}
/**
diff --git a/Source/CTest/cmCTestRunScriptCommand.h b/Source/CTest/cmCTestRunScriptCommand.h
index 9d8b4b5..6961f6e 100644
--- a/Source/CTest/cmCTestRunScriptCommand.h
+++ b/Source/CTest/cmCTestRunScriptCommand.h
@@ -6,11 +6,14 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include "cmCTestCommand.h"
+#include "cmCommand.h"
#include <string>
+#include <utility>
#include <vector>
-class cmCommand;
+#include "cm_memory.hxx"
+
class cmExecutionStatus;
/** \class cmCTestRunScript
@@ -27,12 +30,12 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestRunScriptCommand* ni = new cmCTestRunScriptCommand;
+ auto ni = cm::make_unique<cmCTestRunScriptCommand>();
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
- return ni;
+ return std::unique_ptr<cmCommand>(std::move(ni));
}
/**
diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx
index a739f44..861bd06 100644
--- a/Source/CTest/cmCTestScriptHandler.cxx
+++ b/Source/CTest/cmCTestScriptHandler.cxx
@@ -12,6 +12,8 @@
#include <string.h>
#include <utility>
+#include "cm_memory.hxx"
+
#include "cmCTest.h"
#include "cmCTestBuildCommand.h"
#include "cmCTestCommand.h"
@@ -27,6 +29,7 @@
#include "cmCTestTestCommand.h"
#include "cmCTestUpdateCommand.h"
#include "cmCTestUploadCommand.h"
+#include "cmCommand.h"
#include "cmDuration.h"
#include "cmFunctionBlocker.h"
#include "cmGeneratedFileStream.h"
@@ -167,12 +170,12 @@ void cmCTestScriptHandler::UpdateElapsedTime()
}
}
-void cmCTestScriptHandler::AddCTestCommand(std::string const& name,
- cmCTestCommand* command)
+void cmCTestScriptHandler::AddCTestCommand(
+ std::string const& name, std::unique_ptr<cmCTestCommand> command)
{
command->CTest = this->CTest;
command->CTestScriptHandler = this;
- this->CMake->GetState()->AddBuiltinCommand(name, command);
+ this->CMake->GetState()->AddBuiltinCommand(name, std::move(command));
}
int cmCTestScriptHandler::ExecuteScript(const std::string& total_script_arg)
@@ -295,21 +298,28 @@ void cmCTestScriptHandler::CreateCMake()
}
});
- this->AddCTestCommand("ctest_build", new cmCTestBuildCommand);
- this->AddCTestCommand("ctest_configure", new cmCTestConfigureCommand);
- this->AddCTestCommand("ctest_coverage", new cmCTestCoverageCommand);
+ this->AddCTestCommand("ctest_build", cm::make_unique<cmCTestBuildCommand>());
+ this->AddCTestCommand("ctest_configure",
+ cm::make_unique<cmCTestConfigureCommand>());
+ this->AddCTestCommand("ctest_coverage",
+ cm::make_unique<cmCTestCoverageCommand>());
this->AddCTestCommand("ctest_empty_binary_directory",
- new cmCTestEmptyBinaryDirectoryCommand);
- this->AddCTestCommand("ctest_memcheck", new cmCTestMemCheckCommand);
+ cm::make_unique<cmCTestEmptyBinaryDirectoryCommand>());
+ this->AddCTestCommand("ctest_memcheck",
+ cm::make_unique<cmCTestMemCheckCommand>());
this->AddCTestCommand("ctest_read_custom_files",
- new cmCTestReadCustomFilesCommand);
- this->AddCTestCommand("ctest_run_script", new cmCTestRunScriptCommand);
- this->AddCTestCommand("ctest_sleep", new cmCTestSleepCommand);
- this->AddCTestCommand("ctest_start", new cmCTestStartCommand);
- this->AddCTestCommand("ctest_submit", new cmCTestSubmitCommand);
- this->AddCTestCommand("ctest_test", new cmCTestTestCommand);
- this->AddCTestCommand("ctest_update", new cmCTestUpdateCommand);
- this->AddCTestCommand("ctest_upload", new cmCTestUploadCommand);
+ cm::make_unique<cmCTestReadCustomFilesCommand>());
+ this->AddCTestCommand("ctest_run_script",
+ cm::make_unique<cmCTestRunScriptCommand>());
+ this->AddCTestCommand("ctest_sleep", cm::make_unique<cmCTestSleepCommand>());
+ this->AddCTestCommand("ctest_start", cm::make_unique<cmCTestStartCommand>());
+ this->AddCTestCommand("ctest_submit",
+ cm::make_unique<cmCTestSubmitCommand>());
+ this->AddCTestCommand("ctest_test", cm::make_unique<cmCTestTestCommand>());
+ this->AddCTestCommand("ctest_update",
+ cm::make_unique<cmCTestUpdateCommand>());
+ this->AddCTestCommand("ctest_upload",
+ cm::make_unique<cmCTestUploadCommand>());
}
// this sets up some variables for the script to use, creates the required
diff --git a/Source/CTest/cmCTestScriptHandler.h b/Source/CTest/cmCTestScriptHandler.h
index d93b5f8..b2e8cbf 100644
--- a/Source/CTest/cmCTestScriptHandler.h
+++ b/Source/CTest/cmCTestScriptHandler.h
@@ -9,6 +9,7 @@
#include "cmDuration.h"
#include <chrono>
+#include <memory>
#include <string>
#include <vector>
@@ -131,7 +132,8 @@ private:
int RunConfigurationDashboard();
// Add ctest command
- void AddCTestCommand(std::string const& name, cmCTestCommand* command);
+ void AddCTestCommand(std::string const& name,
+ std::unique_ptr<cmCTestCommand> command);
// Try to remove the binary directory once
static bool TryToRemoveBinaryDirectoryOnce(const std::string& directoryPath);
diff --git a/Source/CTest/cmCTestSleepCommand.h b/Source/CTest/cmCTestSleepCommand.h
index 5cd185a..7b17081 100644
--- a/Source/CTest/cmCTestSleepCommand.h
+++ b/Source/CTest/cmCTestSleepCommand.h
@@ -6,11 +6,14 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include "cmCTestCommand.h"
+#include "cmCommand.h"
#include <string>
+#include <utility>
#include <vector>
-class cmCommand;
+#include "cm_memory.hxx"
+
class cmExecutionStatus;
/** \class cmCTestSleep
@@ -27,12 +30,12 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestSleepCommand* ni = new cmCTestSleepCommand;
+ auto ni = cm::make_unique<cmCTestSleepCommand>();
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
- return ni;
+ return std::unique_ptr<cmCommand>(std::move(ni));
}
/**
diff --git a/Source/CTest/cmCTestStartCommand.h b/Source/CTest/cmCTestStartCommand.h
index 542f27c..7c71f36 100644
--- a/Source/CTest/cmCTestStartCommand.h
+++ b/Source/CTest/cmCTestStartCommand.h
@@ -6,12 +6,15 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include "cmCTestCommand.h"
+#include "cmCommand.h"
#include <iosfwd>
#include <string>
+#include <utility>
#include <vector>
-class cmCommand;
+#include "cm_memory.hxx"
+
class cmExecutionStatus;
/** \class cmCTestStart
@@ -27,14 +30,14 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestStartCommand* ni = new cmCTestStartCommand;
+ auto ni = cm::make_unique<cmCTestStartCommand>();
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
ni->CreateNewTag = this->CreateNewTag;
ni->Quiet = this->Quiet;
- return ni;
+ return std::unique_ptr<cmCommand>(std::move(ni));
}
/**
diff --git a/Source/CTest/cmCTestSubmitCommand.cxx b/Source/CTest/cmCTestSubmitCommand.cxx
index afc3e67..bf43d88 100644
--- a/Source/CTest/cmCTestSubmitCommand.cxx
+++ b/Source/CTest/cmCTestSubmitCommand.cxx
@@ -4,11 +4,15 @@
#include "cmCTest.h"
#include "cmCTestSubmitHandler.h"
+#include "cmCommand.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmSystemTools.h"
#include <sstream>
+#include <utility>
+
+#include "cm_memory.hxx"
class cmExecutionStatus;
@@ -27,12 +31,12 @@ cmCTestSubmitCommand::cmCTestSubmitCommand()
/**
* This is a virtual constructor for the command.
*/
-cmCommand* cmCTestSubmitCommand::Clone()
+std::unique_ptr<cmCommand> cmCTestSubmitCommand::Clone()
{
- cmCTestSubmitCommand* ni = new cmCTestSubmitCommand;
+ auto ni = cm::make_unique<cmCTestSubmitCommand>();
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
- return ni;
+ return std::unique_ptr<cmCommand>(std::move(ni));
}
cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
diff --git a/Source/CTest/cmCTestSubmitCommand.h b/Source/CTest/cmCTestSubmitCommand.h
index 1e27046..5bbcd39 100644
--- a/Source/CTest/cmCTestSubmitCommand.h
+++ b/Source/CTest/cmCTestSubmitCommand.h
@@ -8,12 +8,13 @@
#include "cmCTest.h"
#include "cmCTestHandlerCommand.h"
+#include <memory>
#include <set>
#include <string>
#include <vector>
-class cmCTestGenericHandler;
class cmCommand;
+class cmCTestGenericHandler;
class cmExecutionStatus;
/** \class cmCTestSubmit
@@ -26,7 +27,7 @@ class cmCTestSubmitCommand : public cmCTestHandlerCommand
{
public:
cmCTestSubmitCommand();
- cmCommand* Clone() override;
+ std::unique_ptr<cmCommand> Clone() override;
bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus& status) override;
diff --git a/Source/CTest/cmCTestTestCommand.h b/Source/CTest/cmCTestTestCommand.h
index 11c0db9..d74136c 100644
--- a/Source/CTest/cmCTestTestCommand.h
+++ b/Source/CTest/cmCTestTestCommand.h
@@ -6,11 +6,14 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include "cmCTestHandlerCommand.h"
+#include "cmCommand.h"
#include <string>
+#include <utility>
+
+#include "cm_memory.hxx"
class cmCTestGenericHandler;
-class cmCommand;
/** \class cmCTestTest
* \brief Run a ctest script
@@ -25,12 +28,12 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestTestCommand* ni = new cmCTestTestCommand;
+ auto ni = cm::make_unique<cmCTestTestCommand>();
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
- return ni;
+ return std::unique_ptr<cmCommand>(std::move(ni));
}
/**
diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx
index 46ef809..9916ca3 100644
--- a/Source/CTest/cmCTestTestHandler.cxx
+++ b/Source/CTest/cmCTestTestHandler.cxx
@@ -11,12 +11,14 @@
#include <functional>
#include <iomanip>
#include <iterator>
-#include <memory>
#include <set>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
+#include <utility>
+
+#include "cm_memory.hxx"
#include "cmAlgorithms.h"
#include "cmCTest.h"
@@ -43,11 +45,11 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestSubdirCommand* c = new cmCTestSubdirCommand;
+ auto c = cm::make_unique<cmCTestSubdirCommand>();
c->TestHandler = this->TestHandler;
- return c;
+ return std::unique_ptr<cmCommand>(std::move(c));
}
/**
@@ -122,11 +124,11 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestAddSubdirectoryCommand* c = new cmCTestAddSubdirectoryCommand;
+ auto c = cm::make_unique<cmCTestAddSubdirectoryCommand>();
c->TestHandler = this->TestHandler;
- return c;
+ return std::unique_ptr<cmCommand>(std::move(c));
}
/**
@@ -187,11 +189,11 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestAddTestCommand* c = new cmCTestAddTestCommand;
+ auto c = cm::make_unique<cmCTestAddTestCommand>();
c->TestHandler = this->TestHandler;
- return c;
+ return std::unique_ptr<cmCommand>(std::move(c));
}
/**
@@ -220,11 +222,11 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestSetTestsPropertiesCommand* c = new cmCTestSetTestsPropertiesCommand;
+ auto c = cm::make_unique<cmCTestSetTestsPropertiesCommand>();
c->TestHandler = this->TestHandler;
- return c;
+ return std::unique_ptr<cmCommand>(std::move(c));
}
/**
@@ -249,12 +251,11 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestSetDirectoryPropertiesCommand* c =
- new cmCTestSetDirectoryPropertiesCommand;
+ auto c = cm::make_unique<cmCTestSetDirectoryPropertiesCommand>();
c->TestHandler = this->TestHandler;
- return c;
+ return std::unique_ptr<cmCommand>(std::move(c));
}
/**
@@ -1686,32 +1687,31 @@ void cmCTestTestHandler::GetListOfTests()
this->CTest->GetConfigType().c_str());
// Add handler for ADD_TEST
- cmCTestAddTestCommand* newCom1 = new cmCTestAddTestCommand;
+ auto newCom1 = cm::make_unique<cmCTestAddTestCommand>();
newCom1->TestHandler = this;
- cm.GetState()->AddBuiltinCommand("add_test", newCom1);
+ cm.GetState()->AddBuiltinCommand("add_test", std::move(newCom1));
// Add handler for SUBDIRS
- cmCTestSubdirCommand* newCom2 = new cmCTestSubdirCommand;
+ auto newCom2 = cm::make_unique<cmCTestSubdirCommand>();
newCom2->TestHandler = this;
- cm.GetState()->AddBuiltinCommand("subdirs", newCom2);
+ cm.GetState()->AddBuiltinCommand("subdirs", std::move(newCom2));
// Add handler for ADD_SUBDIRECTORY
- cmCTestAddSubdirectoryCommand* newCom3 = new cmCTestAddSubdirectoryCommand;
+ auto newCom3 = cm::make_unique<cmCTestAddSubdirectoryCommand>();
newCom3->TestHandler = this;
- cm.GetState()->AddBuiltinCommand("add_subdirectory", newCom3);
+ cm.GetState()->AddBuiltinCommand("add_subdirectory", std::move(newCom3));
// Add handler for SET_TESTS_PROPERTIES
- cmCTestSetTestsPropertiesCommand* newCom4 =
- new cmCTestSetTestsPropertiesCommand;
+ auto newCom4 = cm::make_unique<cmCTestSetTestsPropertiesCommand>();
newCom4->TestHandler = this;
- cm.GetState()->AddBuiltinCommand("set_tests_properties", newCom4);
+ cm.GetState()->AddBuiltinCommand("set_tests_properties", std::move(newCom4));
// Add handler for SET_DIRECTORY_PROPERTIES
cm.GetState()->RemoveBuiltinCommand("set_directory_properties");
- cmCTestSetDirectoryPropertiesCommand* newCom5 =
- new cmCTestSetDirectoryPropertiesCommand;
+ auto newCom5 = cm::make_unique<cmCTestSetDirectoryPropertiesCommand>();
newCom5->TestHandler = this;
- cm.GetState()->AddBuiltinCommand("set_directory_properties", newCom5);
+ cm.GetState()->AddBuiltinCommand("set_directory_properties",
+ std::move(newCom5));
const char* testFilename;
if (cmSystemTools::FileExists("CTestTestfile.cmake")) {
diff --git a/Source/CTest/cmCTestUpdateCommand.h b/Source/CTest/cmCTestUpdateCommand.h
index 3b2f3e1..55c4b80 100644
--- a/Source/CTest/cmCTestUpdateCommand.h
+++ b/Source/CTest/cmCTestUpdateCommand.h
@@ -6,11 +6,14 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include "cmCTestHandlerCommand.h"
+#include "cmCommand.h"
#include <string>
+#include <utility>
+
+#include "cm_memory.hxx"
class cmCTestGenericHandler;
-class cmCommand;
/** \class cmCTestUpdate
* \brief Run a ctest script
@@ -25,12 +28,12 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestUpdateCommand* ni = new cmCTestUpdateCommand;
+ auto ni = cm::make_unique<cmCTestUpdateCommand>();
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
- return ni;
+ return std::unique_ptr<cmCommand>(std::move(ni));
}
/**
diff --git a/Source/CTest/cmCTestUploadCommand.h b/Source/CTest/cmCTestUploadCommand.h
index 0d3b06e..2bb072f 100644
--- a/Source/CTest/cmCTestUploadCommand.h
+++ b/Source/CTest/cmCTestUploadCommand.h
@@ -6,12 +6,15 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include "cmCTestHandlerCommand.h"
+#include "cmCommand.h"
#include <set>
#include <string>
+#include <utility>
+
+#include "cm_memory.hxx"
class cmCTestGenericHandler;
-class cmCommand;
/** \class cmCTestUpload
* \brief Run a ctest script
@@ -25,12 +28,12 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmCTestUploadCommand* ni = new cmCTestUploadCommand;
+ auto ni = cm::make_unique<cmCTestUploadCommand>();
ni->CTest = this->CTest;
ni->CTestScriptHandler = this->CTestScriptHandler;
- return ni;
+ return std::unique_ptr<cmCommand>(std::move(ni));
}
/**
diff --git a/Source/cmAddCompileDefinitionsCommand.h b/Source/cmAddCompileDefinitionsCommand.h
index e985dca..5f90ed9 100644
--- a/Source/cmAddCompileDefinitionsCommand.h
+++ b/Source/cmAddCompileDefinitionsCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -18,7 +20,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmAddCompileDefinitionsCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmAddCompileDefinitionsCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmAddCompileOptionsCommand.h b/Source/cmAddCompileOptionsCommand.h
index 3d53d09..b34b7fc 100644
--- a/Source/cmAddCompileOptionsCommand.h
+++ b/Source/cmAddCompileOptionsCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -18,7 +20,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmAddCompileOptionsCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmAddCompileOptionsCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmAddCustomCommandCommand.h b/Source/cmAddCustomCommandCommand.h
index 6af4f10..931aeab 100644
--- a/Source/cmAddCustomCommandCommand.h
+++ b/Source/cmAddCustomCommandCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmAddCustomCommandCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmAddCustomCommandCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmAddCustomTargetCommand.h b/Source/cmAddCustomTargetCommand.h
index 1a55116..db577bc 100644
--- a/Source/cmAddCustomTargetCommand.h
+++ b/Source/cmAddCustomTargetCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -25,7 +27,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmAddCustomTargetCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmAddCustomTargetCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmAddDefinitionsCommand.h b/Source/cmAddDefinitionsCommand.h
index 7b75638..0e32c83 100644
--- a/Source/cmAddDefinitionsCommand.h
+++ b/Source/cmAddDefinitionsCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmAddDefinitionsCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmAddDefinitionsCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmAddDependenciesCommand.h b/Source/cmAddDependenciesCommand.h
index e10df71..ce912d3 100644
--- a/Source/cmAddDependenciesCommand.h
+++ b/Source/cmAddDependenciesCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmAddDependenciesCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmAddDependenciesCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmAddExecutableCommand.h b/Source/cmAddExecutableCommand.h
index bdf607d..ec57c3f 100644
--- a/Source/cmAddExecutableCommand.h
+++ b/Source/cmAddExecutableCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmAddExecutableCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmAddExecutableCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmAddLibraryCommand.h b/Source/cmAddLibraryCommand.h
index aa21261..56dab41 100644
--- a/Source/cmAddLibraryCommand.h
+++ b/Source/cmAddLibraryCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmAddLibraryCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmAddLibraryCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmAddLinkOptionsCommand.h b/Source/cmAddLinkOptionsCommand.h
index 30fff00..8e46be6 100644
--- a/Source/cmAddLinkOptionsCommand.h
+++ b/Source/cmAddLinkOptionsCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -18,7 +20,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmAddLinkOptionsCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmAddLinkOptionsCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmAddSubDirectoryCommand.h b/Source/cmAddSubDirectoryCommand.h
index 0ea4423..664334e 100644
--- a/Source/cmAddSubDirectoryCommand.h
+++ b/Source/cmAddSubDirectoryCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -25,7 +27,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmAddSubDirectoryCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmAddSubDirectoryCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmAddTestCommand.h b/Source/cmAddTestCommand.h
index bea3f3d..3d37d2b 100644
--- a/Source/cmAddTestCommand.h
+++ b/Source/cmAddTestCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmAddTestCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmAddTestCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmAuxSourceDirectoryCommand.h b/Source/cmAuxSourceDirectoryCommand.h
index 3742e3e..973a464 100644
--- a/Source/cmAuxSourceDirectoryCommand.h
+++ b/Source/cmAuxSourceDirectoryCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -27,7 +29,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmAuxSourceDirectoryCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmAuxSourceDirectoryCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmBreakCommand.h b/Source/cmBreakCommand.h
index 3b18567..e6f218e 100644
--- a/Source/cmBreakCommand.h
+++ b/Source/cmBreakCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmBreakCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmBreakCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmBuildCommand.h b/Source/cmBuildCommand.h
index e0529a4..d373103 100644
--- a/Source/cmBuildCommand.h
+++ b/Source/cmBuildCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmBuildCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmBuildCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmBuildNameCommand.h b/Source/cmBuildNameCommand.h
index 4bb72d1..bd2d146 100644
--- a/Source/cmBuildNameCommand.h
+++ b/Source/cmBuildNameCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -15,7 +17,10 @@ class cmExecutionStatus;
class cmBuildNameCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmBuildNameCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmBuildNameCommand>();
+ }
bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus& status) override;
};
diff --git a/Source/cmCMakeHostSystemInformationCommand.h b/Source/cmCMakeHostSystemInformationCommand.h
index b871641..8ea2d55 100644
--- a/Source/cmCMakeHostSystemInformationCommand.h
+++ b/Source/cmCMakeHostSystemInformationCommand.h
@@ -9,6 +9,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -28,9 +30,9 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- return new cmCMakeHostSystemInformationCommand;
+ return cm::make_unique<cmCMakeHostSystemInformationCommand>();
}
/**
diff --git a/Source/cmCMakeMinimumRequired.h b/Source/cmCMakeMinimumRequired.h
index f9b61e1..3881133 100644
--- a/Source/cmCMakeMinimumRequired.h
+++ b/Source/cmCMakeMinimumRequired.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmCMakeMinimumRequired; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmCMakeMinimumRequired>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmCMakePolicyCommand.h b/Source/cmCMakePolicyCommand.h
index cca1406..919402c 100644
--- a/Source/cmCMakePolicyCommand.h
+++ b/Source/cmCMakePolicyCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmCMakePolicyCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmCMakePolicyCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmCommand.h b/Source/cmCommand.h
index 9ccd773..cdd2aba 100644
--- a/Source/cmCommand.h
+++ b/Source/cmCommand.h
@@ -5,6 +5,7 @@
#include "cmConfigure.h" // IWYU pragma: keep
+#include <memory>
#include <string>
#include <vector>
@@ -75,7 +76,7 @@ public:
/**
* This is a virtual constructor for the command.
*/
- virtual cmCommand* Clone() = 0;
+ virtual std::unique_ptr<cmCommand> Clone() = 0;
/**
* Return the last error string.
diff --git a/Source/cmCommands.cxx b/Source/cmCommands.cxx
index 63c5397..96c7105 100644
--- a/Source/cmCommands.cxx
+++ b/Source/cmCommands.cxx
@@ -1,5 +1,8 @@
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
+
+#include "cm_memory.hxx"
+
#include "cmCommands.h"
#include "cmPolicies.h"
#include "cmState.h"
@@ -17,6 +20,7 @@
#include "cmBuildCommand.h"
#include "cmCMakeMinimumRequired.h"
#include "cmCMakePolicyCommand.h"
+#include "cmCommand.h"
#include "cmConfigureFileCommand.h"
#include "cmContinueCommand.h"
#include "cmCreateTestSourceList.h"
@@ -112,52 +116,64 @@
void GetScriptingCommands(cmState* state)
{
- state->AddBuiltinCommand("break", new cmBreakCommand);
+ state->AddBuiltinCommand("break", cm::make_unique<cmBreakCommand>());
state->AddBuiltinCommand("cmake_minimum_required",
- new cmCMakeMinimumRequired);
- state->AddBuiltinCommand("cmake_policy", new cmCMakePolicyCommand);
- state->AddBuiltinCommand("configure_file", new cmConfigureFileCommand);
- state->AddBuiltinCommand("continue", new cmContinueCommand);
- state->AddBuiltinCommand("exec_program", new cmExecProgramCommand);
- state->AddBuiltinCommand("execute_process", new cmExecuteProcessCommand);
- state->AddBuiltinCommand("file", new cmFileCommand);
- state->AddBuiltinCommand("find_file", new cmFindFileCommand);
- state->AddBuiltinCommand("find_library", new cmFindLibraryCommand);
- state->AddBuiltinCommand("find_package", new cmFindPackageCommand);
- state->AddBuiltinCommand("find_path", new cmFindPathCommand);
- state->AddBuiltinCommand("find_program", new cmFindProgramCommand);
- state->AddBuiltinCommand("foreach", new cmForEachCommand);
- state->AddBuiltinCommand("function", new cmFunctionCommand);
+ cm::make_unique<cmCMakeMinimumRequired>());
+ state->AddBuiltinCommand("cmake_policy",
+ cm::make_unique<cmCMakePolicyCommand>());
+ state->AddBuiltinCommand("configure_file",
+ cm::make_unique<cmConfigureFileCommand>());
+ state->AddBuiltinCommand("continue", cm::make_unique<cmContinueCommand>());
+ state->AddBuiltinCommand("exec_program",
+ cm::make_unique<cmExecProgramCommand>());
+ state->AddBuiltinCommand("execute_process",
+ cm::make_unique<cmExecuteProcessCommand>());
+ state->AddBuiltinCommand("file", cm::make_unique<cmFileCommand>());
+ state->AddBuiltinCommand("find_file", cm::make_unique<cmFindFileCommand>());
+ state->AddBuiltinCommand("find_library",
+ cm::make_unique<cmFindLibraryCommand>());
+ state->AddBuiltinCommand("find_package",
+ cm::make_unique<cmFindPackageCommand>());
+ state->AddBuiltinCommand("find_path", cm::make_unique<cmFindPathCommand>());
+ state->AddBuiltinCommand("find_program",
+ cm::make_unique<cmFindProgramCommand>());
+ state->AddBuiltinCommand("foreach", cm::make_unique<cmForEachCommand>());
+ state->AddBuiltinCommand("function", cm::make_unique<cmFunctionCommand>());
state->AddBuiltinCommand("get_cmake_property",
- new cmGetCMakePropertyCommand);
+ cm::make_unique<cmGetCMakePropertyCommand>());
state->AddBuiltinCommand("get_directory_property",
- new cmGetDirectoryPropertyCommand);
+ cm::make_unique<cmGetDirectoryPropertyCommand>());
state->AddBuiltinCommand("get_filename_component",
- new cmGetFilenameComponentCommand);
- state->AddBuiltinCommand("get_property", new cmGetPropertyCommand);
- state->AddBuiltinCommand("if", new cmIfCommand);
- state->AddBuiltinCommand("include", new cmIncludeCommand);
- state->AddBuiltinCommand("include_guard", new cmIncludeGuardCommand);
- state->AddBuiltinCommand("list", new cmListCommand);
- state->AddBuiltinCommand("macro", new cmMacroCommand);
- state->AddBuiltinCommand("make_directory", new cmMakeDirectoryCommand);
- state->AddBuiltinCommand("mark_as_advanced", new cmMarkAsAdvancedCommand);
- state->AddBuiltinCommand("math", new cmMathCommand);
- state->AddBuiltinCommand("message", new cmMessageCommand);
- state->AddBuiltinCommand("option", new cmOptionCommand);
+ cm::make_unique<cmGetFilenameComponentCommand>());
+ state->AddBuiltinCommand("get_property",
+ cm::make_unique<cmGetPropertyCommand>());
+ state->AddBuiltinCommand("if", cm::make_unique<cmIfCommand>());
+ state->AddBuiltinCommand("include", cm::make_unique<cmIncludeCommand>());
+ state->AddBuiltinCommand("include_guard",
+ cm::make_unique<cmIncludeGuardCommand>());
+ state->AddBuiltinCommand("list", cm::make_unique<cmListCommand>());
+ state->AddBuiltinCommand("macro", cm::make_unique<cmMacroCommand>());
+ state->AddBuiltinCommand("make_directory",
+ cm::make_unique<cmMakeDirectoryCommand>());
+ state->AddBuiltinCommand("mark_as_advanced",
+ cm::make_unique<cmMarkAsAdvancedCommand>());
+ state->AddBuiltinCommand("math", cm::make_unique<cmMathCommand>());
+ state->AddBuiltinCommand("message", cm::make_unique<cmMessageCommand>());
+ state->AddBuiltinCommand("option", cm::make_unique<cmOptionCommand>());
state->AddBuiltinCommand("cmake_parse_arguments",
- new cmParseArgumentsCommand);
- state->AddBuiltinCommand("return", new cmReturnCommand);
+ cm::make_unique<cmParseArgumentsCommand>());
+ state->AddBuiltinCommand("return", cm::make_unique<cmReturnCommand>());
state->AddBuiltinCommand("separate_arguments",
- new cmSeparateArgumentsCommand);
- state->AddBuiltinCommand("set", new cmSetCommand);
+ cm::make_unique<cmSeparateArgumentsCommand>());
+ state->AddBuiltinCommand("set", cm::make_unique<cmSetCommand>());
state->AddBuiltinCommand("set_directory_properties",
- new cmSetDirectoryPropertiesCommand);
- state->AddBuiltinCommand("set_property", new cmSetPropertyCommand);
- state->AddBuiltinCommand("site_name", new cmSiteNameCommand);
- state->AddBuiltinCommand("string", new cmStringCommand);
- state->AddBuiltinCommand("unset", new cmUnsetCommand);
- state->AddBuiltinCommand("while", new cmWhileCommand);
+ cm::make_unique<cmSetDirectoryPropertiesCommand>());
+ state->AddBuiltinCommand("set_property",
+ cm::make_unique<cmSetPropertyCommand>());
+ state->AddBuiltinCommand("site_name", cm::make_unique<cmSiteNameCommand>());
+ state->AddBuiltinCommand("string", cm::make_unique<cmStringCommand>());
+ state->AddBuiltinCommand("unset", cm::make_unique<cmUnsetCommand>());
+ state->AddBuiltinCommand("while", cm::make_unique<cmWhileCommand>());
state->AddUnexpectedCommand(
"else",
@@ -195,17 +211,21 @@ void GetScriptingCommands(cmState* state)
"match the opening WHILE command.");
#if defined(CMAKE_BUILD_WITH_CMAKE)
- state->AddBuiltinCommand("cmake_host_system_information",
- new cmCMakeHostSystemInformationCommand);
- state->AddBuiltinCommand("remove", new cmRemoveCommand);
- state->AddBuiltinCommand("variable_watch", new cmVariableWatchCommand);
- state->AddBuiltinCommand("write_file", new cmWriteFileCommand);
+ state->AddBuiltinCommand(
+ "cmake_host_system_information",
+ cm::make_unique<cmCMakeHostSystemInformationCommand>());
+ state->AddBuiltinCommand("remove", cm::make_unique<cmRemoveCommand>());
+ state->AddBuiltinCommand("variable_watch",
+ cm::make_unique<cmVariableWatchCommand>());
+ state->AddBuiltinCommand("write_file",
+ cm::make_unique<cmWriteFileCommand>());
state->AddDisallowedCommand(
- "build_name", new cmBuildNameCommand, cmPolicies::CMP0036,
+ "build_name", cm::make_unique<cmBuildNameCommand>(), cmPolicies::CMP0036,
"The build_name command should not be called; see CMP0036.");
state->AddDisallowedCommand(
- "use_mangled_mesa", new cmUseMangledMesaCommand, cmPolicies::CMP0030,
+ "use_mangled_mesa", cm::make_unique<cmUseMangledMesaCommand>(),
+ cmPolicies::CMP0030,
"The use_mangled_mesa command should not be called; see CMP0030.");
#endif
@@ -214,100 +234,131 @@ void GetScriptingCommands(cmState* state)
void GetProjectCommands(cmState* state)
{
state->AddBuiltinCommand("add_custom_command",
- new cmAddCustomCommandCommand);
- state->AddBuiltinCommand("add_custom_target", new cmAddCustomTargetCommand);
- state->AddBuiltinCommand("add_definitions", new cmAddDefinitionsCommand);
- state->AddBuiltinCommand("add_dependencies", new cmAddDependenciesCommand);
- state->AddBuiltinCommand("add_executable", new cmAddExecutableCommand);
- state->AddBuiltinCommand("add_library", new cmAddLibraryCommand);
- state->AddBuiltinCommand("add_subdirectory", new cmAddSubDirectoryCommand);
- state->AddBuiltinCommand("add_test", new cmAddTestCommand);
- state->AddBuiltinCommand("build_command", new cmBuildCommand);
+ cm::make_unique<cmAddCustomCommandCommand>());
+ state->AddBuiltinCommand("add_custom_target",
+ cm::make_unique<cmAddCustomTargetCommand>());
+ state->AddBuiltinCommand("add_definitions",
+ cm::make_unique<cmAddDefinitionsCommand>());
+ state->AddBuiltinCommand("add_dependencies",
+ cm::make_unique<cmAddDependenciesCommand>());
+ state->AddBuiltinCommand("add_executable",
+ cm::make_unique<cmAddExecutableCommand>());
+ state->AddBuiltinCommand("add_library",
+ cm::make_unique<cmAddLibraryCommand>());
+ state->AddBuiltinCommand("add_subdirectory",
+ cm::make_unique<cmAddSubDirectoryCommand>());
+ state->AddBuiltinCommand("add_test", cm::make_unique<cmAddTestCommand>());
+ state->AddBuiltinCommand("build_command", cm::make_unique<cmBuildCommand>());
state->AddBuiltinCommand("create_test_sourcelist",
- new cmCreateTestSourceList);
- state->AddBuiltinCommand("define_property", new cmDefinePropertyCommand);
- state->AddBuiltinCommand("enable_language", new cmEnableLanguageCommand);
- state->AddBuiltinCommand("enable_testing", new cmEnableTestingCommand);
+ cm::make_unique<cmCreateTestSourceList>());
+ state->AddBuiltinCommand("define_property",
+ cm::make_unique<cmDefinePropertyCommand>());
+ state->AddBuiltinCommand("enable_language",
+ cm::make_unique<cmEnableLanguageCommand>());
+ state->AddBuiltinCommand("enable_testing",
+ cm::make_unique<cmEnableTestingCommand>());
state->AddBuiltinCommand("get_source_file_property",
- new cmGetSourceFilePropertyCommand);
+ cm::make_unique<cmGetSourceFilePropertyCommand>());
state->AddBuiltinCommand("get_target_property",
- new cmGetTargetPropertyCommand);
- state->AddBuiltinCommand("get_test_property", new cmGetTestPropertyCommand);
+ cm::make_unique<cmGetTargetPropertyCommand>());
+ state->AddBuiltinCommand("get_test_property",
+ cm::make_unique<cmGetTestPropertyCommand>());
state->AddBuiltinCommand("include_directories",
- new cmIncludeDirectoryCommand);
- state->AddBuiltinCommand("include_regular_expression",
- new cmIncludeRegularExpressionCommand);
- state->AddBuiltinCommand("install", new cmInstallCommand);
- state->AddBuiltinCommand("install_files", new cmInstallFilesCommand);
- state->AddBuiltinCommand("install_targets", new cmInstallTargetsCommand);
- state->AddBuiltinCommand("link_directories", new cmLinkDirectoriesCommand);
- state->AddBuiltinCommand("project", new cmProjectCommand);
- state->AddBuiltinCommand("set_source_files_properties",
- new cmSetSourceFilesPropertiesCommand);
+ cm::make_unique<cmIncludeDirectoryCommand>());
+ state->AddBuiltinCommand(
+ "include_regular_expression",
+ cm::make_unique<cmIncludeRegularExpressionCommand>());
+ state->AddBuiltinCommand("install", cm::make_unique<cmInstallCommand>());
+ state->AddBuiltinCommand("install_files",
+ cm::make_unique<cmInstallFilesCommand>());
+ state->AddBuiltinCommand("install_targets",
+ cm::make_unique<cmInstallTargetsCommand>());
+ state->AddBuiltinCommand("link_directories",
+ cm::make_unique<cmLinkDirectoriesCommand>());
+ state->AddBuiltinCommand("project", cm::make_unique<cmProjectCommand>());
+ state->AddBuiltinCommand(
+ "set_source_files_properties",
+ cm::make_unique<cmSetSourceFilesPropertiesCommand>());
state->AddBuiltinCommand("set_target_properties",
- new cmSetTargetPropertiesCommand);
+ cm::make_unique<cmSetTargetPropertiesCommand>());
state->AddBuiltinCommand("set_tests_properties",
- new cmSetTestsPropertiesCommand);
- state->AddBuiltinCommand("subdirs", new cmSubdirCommand);
- state->AddBuiltinCommand("target_compile_definitions",
- new cmTargetCompileDefinitionsCommand);
+ cm::make_unique<cmSetTestsPropertiesCommand>());
+ state->AddBuiltinCommand("subdirs", cm::make_unique<cmSubdirCommand>());
+ state->AddBuiltinCommand(
+ "target_compile_definitions",
+ cm::make_unique<cmTargetCompileDefinitionsCommand>());
state->AddBuiltinCommand("target_compile_features",
- new cmTargetCompileFeaturesCommand);
+ cm::make_unique<cmTargetCompileFeaturesCommand>());
state->AddBuiltinCommand("target_compile_options",
- new cmTargetCompileOptionsCommand);
- state->AddBuiltinCommand("target_include_directories",
- new cmTargetIncludeDirectoriesCommand);
+ cm::make_unique<cmTargetCompileOptionsCommand>());
+ state->AddBuiltinCommand(
+ "target_include_directories",
+ cm::make_unique<cmTargetIncludeDirectoriesCommand>());
state->AddBuiltinCommand("target_link_libraries",
- new cmTargetLinkLibrariesCommand);
- state->AddBuiltinCommand("target_sources", new cmTargetSourcesCommand);
- state->AddBuiltinCommand("try_compile", new cmTryCompileCommand);
- state->AddBuiltinCommand("try_run", new cmTryRunCommand);
+ cm::make_unique<cmTargetLinkLibrariesCommand>());
+ state->AddBuiltinCommand("target_sources",
+ cm::make_unique<cmTargetSourcesCommand>());
+ state->AddBuiltinCommand("try_compile",
+ cm::make_unique<cmTryCompileCommand>());
+ state->AddBuiltinCommand("try_run", cm::make_unique<cmTryRunCommand>());
#if defined(CMAKE_BUILD_WITH_CMAKE)
state->AddBuiltinCommand("add_compile_definitions",
- new cmAddCompileDefinitionsCommand);
+ cm::make_unique<cmAddCompileDefinitionsCommand>());
state->AddBuiltinCommand("add_compile_options",
- new cmAddCompileOptionsCommand);
+ cm::make_unique<cmAddCompileOptionsCommand>());
state->AddBuiltinCommand("aux_source_directory",
- new cmAuxSourceDirectoryCommand);
- state->AddBuiltinCommand("export", new cmExportCommand);
- state->AddBuiltinCommand("fltk_wrap_ui", new cmFLTKWrapUICommand);
- state->AddBuiltinCommand("include_external_msproject",
- new cmIncludeExternalMSProjectCommand);
- state->AddBuiltinCommand("install_programs", new cmInstallProgramsCommand);
- state->AddBuiltinCommand("add_link_options", new cmAddLinkOptionsCommand);
- state->AddBuiltinCommand("link_libraries", new cmLinkLibrariesCommand);
+ cm::make_unique<cmAuxSourceDirectoryCommand>());
+ state->AddBuiltinCommand("export", cm::make_unique<cmExportCommand>());
+ state->AddBuiltinCommand("fltk_wrap_ui",
+ cm::make_unique<cmFLTKWrapUICommand>());
+ state->AddBuiltinCommand(
+ "include_external_msproject",
+ cm::make_unique<cmIncludeExternalMSProjectCommand>());
+ state->AddBuiltinCommand("install_programs",
+ cm::make_unique<cmInstallProgramsCommand>());
+ state->AddBuiltinCommand("add_link_options",
+ cm::make_unique<cmAddLinkOptionsCommand>());
+ state->AddBuiltinCommand("link_libraries",
+ cm::make_unique<cmLinkLibrariesCommand>());
state->AddBuiltinCommand("target_link_options",
- new cmTargetLinkOptionsCommand);
+ cm::make_unique<cmTargetLinkOptionsCommand>());
state->AddBuiltinCommand("target_link_directories",
- new cmTargetLinkDirectoriesCommand);
- state->AddBuiltinCommand("load_cache", new cmLoadCacheCommand);
- state->AddBuiltinCommand("qt_wrap_cpp", new cmQTWrapCPPCommand);
- state->AddBuiltinCommand("qt_wrap_ui", new cmQTWrapUICommand);
+ cm::make_unique<cmTargetLinkDirectoriesCommand>());
+ state->AddBuiltinCommand("load_cache",
+ cm::make_unique<cmLoadCacheCommand>());
+ state->AddBuiltinCommand("qt_wrap_cpp",
+ cm::make_unique<cmQTWrapCPPCommand>());
+ state->AddBuiltinCommand("qt_wrap_ui", cm::make_unique<cmQTWrapUICommand>());
state->AddBuiltinCommand("remove_definitions",
- new cmRemoveDefinitionsCommand);
- state->AddBuiltinCommand("source_group", new cmSourceGroupCommand);
+ cm::make_unique<cmRemoveDefinitionsCommand>());
+ state->AddBuiltinCommand("source_group",
+ cm::make_unique<cmSourceGroupCommand>());
state->AddDisallowedCommand(
- "export_library_dependencies", new cmExportLibraryDependenciesCommand,
- cmPolicies::CMP0033,
+ "export_library_dependencies",
+ cm::make_unique<cmExportLibraryDependenciesCommand>(), cmPolicies::CMP0033,
"The export_library_dependencies command should not be called; "
"see CMP0033.");
state->AddDisallowedCommand(
- "load_command", new cmLoadCommandCommand, cmPolicies::CMP0031,
+ "load_command", cm::make_unique<cmLoadCommandCommand>(),
+ cmPolicies::CMP0031,
"The load_command command should not be called; see CMP0031.");
state->AddDisallowedCommand(
- "output_required_files", new cmOutputRequiredFilesCommand,
+ "output_required_files", cm::make_unique<cmOutputRequiredFilesCommand>(),
cmPolicies::CMP0032,
"The output_required_files command should not be called; see CMP0032.");
state->AddDisallowedCommand(
- "subdir_depends", new cmSubdirDependsCommand, cmPolicies::CMP0029,
+ "subdir_depends", cm::make_unique<cmSubdirDependsCommand>(),
+ cmPolicies::CMP0029,
"The subdir_depends command should not be called; see CMP0029.");
state->AddDisallowedCommand(
- "utility_source", new cmUtilitySourceCommand, cmPolicies::CMP0034,
+ "utility_source", cm::make_unique<cmUtilitySourceCommand>(),
+ cmPolicies::CMP0034,
"The utility_source command should not be called; see CMP0034.");
state->AddDisallowedCommand(
- "variable_requires", new cmVariableRequiresCommand, cmPolicies::CMP0035,
+ "variable_requires", cm::make_unique<cmVariableRequiresCommand>(),
+ cmPolicies::CMP0035,
"The variable_requires command should not be called; see CMP0035.");
#endif
}
diff --git a/Source/cmConfigureFileCommand.h b/Source/cmConfigureFileCommand.h
index 5603c50..b3a99d7 100644
--- a/Source/cmConfigureFileCommand.h
+++ b/Source/cmConfigureFileCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
#include "cmNewLineStyle.h"
@@ -16,7 +18,10 @@ class cmExecutionStatus;
class cmConfigureFileCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmConfigureFileCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmConfigureFileCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmContinueCommand.h b/Source/cmContinueCommand.h
index d383d1d..a85010a 100644
--- a/Source/cmContinueCommand.h
+++ b/Source/cmContinueCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmContinueCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmContinueCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmCreateTestSourceList.h b/Source/cmCreateTestSourceList.h
index 005b32c..5aa6af4 100644
--- a/Source/cmCreateTestSourceList.h
+++ b/Source/cmCreateTestSourceList.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmCreateTestSourceList; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmCreateTestSourceList>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmDefinePropertyCommand.h b/Source/cmDefinePropertyCommand.h
index a9c1856..36f97df 100644
--- a/Source/cmDefinePropertyCommand.h
+++ b/Source/cmDefinePropertyCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -15,7 +17,10 @@ class cmExecutionStatus;
class cmDefinePropertyCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmDefinePropertyCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmDefinePropertyCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmDisallowedCommand.h b/Source/cmDisallowedCommand.h
index d85c00f..eed59ca 100644
--- a/Source/cmDisallowedCommand.h
+++ b/Source/cmDisallowedCommand.h
@@ -6,8 +6,11 @@
#include "cmConfigure.h" // IWYU pragma: keep
#include <string>
+#include <utility>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
#include "cmPolicies.h"
@@ -16,20 +19,20 @@ class cmExecutionStatus;
class cmDisallowedCommand : public cmCommand
{
public:
- cmDisallowedCommand(cmCommand* command, cmPolicies::PolicyID policy,
- const char* message)
- : Command(command)
+ cmDisallowedCommand(std::unique_ptr<cmCommand> command,
+ cmPolicies::PolicyID policy, const char* message)
+ : Command(std::move(command))
, Policy(policy)
, Message(message)
{
}
- ~cmDisallowedCommand() override { delete this->Command; }
+ ~cmDisallowedCommand() override = default;
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- return new cmDisallowedCommand(this->Command->Clone(), this->Policy,
- this->Message);
+ return cm::make_unique<cmDisallowedCommand>(this->Command->Clone(),
+ this->Policy, this->Message);
}
bool InitialPass(std::vector<std::string> const& args,
@@ -40,7 +43,7 @@ public:
bool HasFinalPass() const override { return this->Command->HasFinalPass(); }
private:
- cmCommand* Command;
+ std::unique_ptr<cmCommand> Command;
cmPolicies::PolicyID Policy;
const char* Message;
};
diff --git a/Source/cmEnableLanguageCommand.h b/Source/cmEnableLanguageCommand.h
index 97645a9..dc43e34 100644
--- a/Source/cmEnableLanguageCommand.h
+++ b/Source/cmEnableLanguageCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -26,7 +28,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmEnableLanguageCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmEnableLanguageCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmEnableTestingCommand.h b/Source/cmEnableTestingCommand.h
index 88a17b9..fd50ebc 100644
--- a/Source/cmEnableTestingCommand.h
+++ b/Source/cmEnableTestingCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -31,7 +33,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmEnableTestingCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmEnableTestingCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmExecProgramCommand.h b/Source/cmExecProgramCommand.h
index ae0fa9b..70f833a 100644
--- a/Source/cmExecProgramCommand.h
+++ b/Source/cmExecProgramCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
#include "cmProcessOutput.h"
@@ -27,7 +29,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmExecProgramCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmExecProgramCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmExecuteProcessCommand.cxx b/Source/cmExecuteProcessCommand.cxx
index 121f33f..689fc20 100644
--- a/Source/cmExecuteProcessCommand.cxx
+++ b/Source/cmExecuteProcessCommand.cxx
@@ -8,7 +8,6 @@
#include <algorithm>
#include <ctype.h> /* isspace */
#include <iostream>
-#include <memory>
#include <stdio.h>
#include <vector>
diff --git a/Source/cmExecuteProcessCommand.h b/Source/cmExecuteProcessCommand.h
index b415deb..1d5445f 100644
--- a/Source/cmExecuteProcessCommand.h
+++ b/Source/cmExecuteProcessCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmExecuteProcessCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmExecuteProcessCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmExportCommand.h b/Source/cmExportCommand.h
index 99f9932..50463af 100644
--- a/Source/cmExportCommand.h
+++ b/Source/cmExportCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -18,7 +20,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmExportCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmExportCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmExportLibraryDependenciesCommand.h b/Source/cmExportLibraryDependenciesCommand.h
index 8414866..5255d63 100644
--- a/Source/cmExportLibraryDependenciesCommand.h
+++ b/Source/cmExportLibraryDependenciesCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -15,9 +17,9 @@ class cmExecutionStatus;
class cmExportLibraryDependenciesCommand : public cmCommand
{
public:
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- return new cmExportLibraryDependenciesCommand;
+ return cm::make_unique<cmExportLibraryDependenciesCommand>();
}
bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus& status) override;
diff --git a/Source/cmFLTKWrapUICommand.h b/Source/cmFLTKWrapUICommand.h
index 044755e..bff4f01 100644
--- a/Source/cmFLTKWrapUICommand.h
+++ b/Source/cmFLTKWrapUICommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -25,7 +27,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmFLTKWrapUICommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmFLTKWrapUICommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmFileCommand.h b/Source/cmFileCommand.h
index cfff894..d4b980e 100644
--- a/Source/cmFileCommand.h
+++ b/Source/cmFileCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -22,7 +24,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmFileCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmFileCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmFindFileCommand.h b/Source/cmFindFileCommand.h
index 4309449..152b505 100644
--- a/Source/cmFindFileCommand.h
+++ b/Source/cmFindFileCommand.h
@@ -5,9 +5,10 @@
#include "cmConfigure.h" // IWYU pragma: keep
-#include "cmFindPathCommand.h"
+#include "cm_memory.hxx"
-class cmCommand;
+#include "cmCommand.h"
+#include "cmFindPathCommand.h"
/** \class cmFindFileCommand
* \brief Define a command to search for an executable program.
@@ -24,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmFindFileCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmFindFileCommand>();
+ }
};
#endif
diff --git a/Source/cmFindLibraryCommand.h b/Source/cmFindLibraryCommand.h
index fb8a700..af17d60 100644
--- a/Source/cmFindLibraryCommand.h
+++ b/Source/cmFindLibraryCommand.h
@@ -8,9 +8,11 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
+#include "cmCommand.h"
#include "cmFindBase.h"
-class cmCommand;
class cmExecutionStatus;
/** \class cmFindLibraryCommand
@@ -27,7 +29,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmFindLibraryCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmFindLibraryCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmFindPackageCommand.h b/Source/cmFindPackageCommand.h
index 316ca0f..f6645ae 100644
--- a/Source/cmFindPackageCommand.h
+++ b/Source/cmFindPackageCommand.h
@@ -3,6 +3,7 @@
#ifndef cmFindPackageCommand_h
#define cmFindPackageCommand_h
+#include "cmCommand.h"
#include "cmConfigure.h" // IWYU pragma: keep
#include "cmPolicies.h"
@@ -14,6 +15,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
// IWYU insists we should forward-declare instead of including <functional>,
// but we cannot forward-declare reliably because some C++ standard libraries
// put the template in an inline namespace.
@@ -27,7 +30,6 @@ namespace std {
#include "cmFindCommon.h"
-class cmCommand;
class cmExecutionStatus;
class cmSearchPath;
@@ -65,7 +67,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmFindPackageCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmFindPackageCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmFindPathCommand.h b/Source/cmFindPathCommand.h
index cb0db4c..89e2cef 100644
--- a/Source/cmFindPathCommand.h
+++ b/Source/cmFindPathCommand.h
@@ -8,9 +8,11 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
+#include "cmCommand.h"
#include "cmFindBase.h"
-class cmCommand;
class cmExecutionStatus;
/** \class cmFindPathCommand
@@ -27,7 +29,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmFindPathCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmFindPathCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmFindProgramCommand.h b/Source/cmFindProgramCommand.h
index 147936c..40e455e 100644
--- a/Source/cmFindProgramCommand.h
+++ b/Source/cmFindProgramCommand.h
@@ -8,9 +8,11 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
+#include "cmCommand.h"
#include "cmFindBase.h"
-class cmCommand;
class cmExecutionStatus;
/** \class cmFindProgramCommand
@@ -28,7 +30,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmFindProgramCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmFindProgramCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmForEachCommand.h b/Source/cmForEachCommand.h
index 5131a4f..cd112b8 100644
--- a/Source/cmForEachCommand.h
+++ b/Source/cmForEachCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
#include "cmFunctionBlocker.h"
#include "cmListFileCache.h"
@@ -39,7 +41,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmForEachCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmForEachCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmFunctionCommand.cxx b/Source/cmFunctionCommand.cxx
index 9067a5f..8e003ad 100644
--- a/Source/cmFunctionCommand.cxx
+++ b/Source/cmFunctionCommand.cxx
@@ -3,6 +3,9 @@
#include "cmFunctionCommand.h"
#include <sstream>
+#include <utility>
+
+#include "cm_memory.hxx"
#include "cmAlgorithms.h"
#include "cmExecutionStatus.h"
@@ -18,15 +21,15 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmFunctionHelperCommand* newC = new cmFunctionHelperCommand;
+ auto newC = cm::make_unique<cmFunctionHelperCommand>();
// we must copy when we clone
newC->Args = this->Args;
newC->Functions = this->Functions;
newC->Policies = this->Policies;
newC->FilePath = this->FilePath;
- return newC;
+ return std::unique_ptr<cmCommand>(std::move(newC));
}
/**
@@ -129,12 +132,12 @@ bool cmFunctionFunctionBlocker::IsFunctionBlocked(
// if this is the endfunction for this function then execute
if (!this->Depth) {
// create a new command and add it to cmake
- cmFunctionHelperCommand* f = new cmFunctionHelperCommand();
+ auto f = cm::make_unique<cmFunctionHelperCommand>();
f->Args = this->Args;
f->Functions = this->Functions;
f->FilePath = this->GetStartingContext().FilePath;
mf.RecordPolicies(f->Policies);
- mf.GetState()->AddScriptedCommand(this->Args[0], f);
+ mf.GetState()->AddScriptedCommand(this->Args[0], std::move(f));
// remove the function blocker now that the function is defined
mf.RemoveFunctionBlocker(this, lff);
return true;
diff --git a/Source/cmFunctionCommand.h b/Source/cmFunctionCommand.h
index 8b37df0..449a180 100644
--- a/Source/cmFunctionCommand.h
+++ b/Source/cmFunctionCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
#include "cmFunctionBlocker.h"
#include "cmListFileCache.h"
@@ -34,7 +36,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmFunctionCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmFunctionCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmGetCMakePropertyCommand.h b/Source/cmGetCMakePropertyCommand.h
index 1f29c78..7790a6b 100644
--- a/Source/cmGetCMakePropertyCommand.h
+++ b/Source/cmGetCMakePropertyCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -15,7 +17,10 @@ class cmExecutionStatus;
class cmGetCMakePropertyCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmGetCMakePropertyCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmGetCMakePropertyCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmGetDirectoryPropertyCommand.h b/Source/cmGetDirectoryPropertyCommand.h
index 02ea056..63a198a 100644
--- a/Source/cmGetDirectoryPropertyCommand.h
+++ b/Source/cmGetDirectoryPropertyCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -15,7 +17,10 @@ class cmExecutionStatus;
class cmGetDirectoryPropertyCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmGetDirectoryPropertyCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmGetDirectoryPropertyCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmGetFilenameComponentCommand.h b/Source/cmGetFilenameComponentCommand.h
index 8c26655..1780b96 100644
--- a/Source/cmGetFilenameComponentCommand.h
+++ b/Source/cmGetFilenameComponentCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmGetFilenameComponentCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmGetFilenameComponentCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmGetPropertyCommand.h b/Source/cmGetPropertyCommand.h
index c3f653e..50e4014 100644
--- a/Source/cmGetPropertyCommand.h
+++ b/Source/cmGetPropertyCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -17,7 +19,10 @@ class cmGetPropertyCommand : public cmCommand
public:
cmGetPropertyCommand();
- cmCommand* Clone() override { return new cmGetPropertyCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmGetPropertyCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmGetSourceFilePropertyCommand.h b/Source/cmGetSourceFilePropertyCommand.h
index 43bc330..387a7f4 100644
--- a/Source/cmGetSourceFilePropertyCommand.h
+++ b/Source/cmGetSourceFilePropertyCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -15,7 +17,10 @@ class cmExecutionStatus;
class cmGetSourceFilePropertyCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmGetSourceFilePropertyCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmGetSourceFilePropertyCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmGetTargetPropertyCommand.h b/Source/cmGetTargetPropertyCommand.h
index 63ee5fd..1a53195 100644
--- a/Source/cmGetTargetPropertyCommand.h
+++ b/Source/cmGetTargetPropertyCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -15,7 +17,10 @@ class cmExecutionStatus;
class cmGetTargetPropertyCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmGetTargetPropertyCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmGetTargetPropertyCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmGetTestPropertyCommand.h b/Source/cmGetTestPropertyCommand.h
index 4a74f59..a53a7f7 100644
--- a/Source/cmGetTestPropertyCommand.h
+++ b/Source/cmGetTestPropertyCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -15,7 +17,10 @@ class cmExecutionStatus;
class cmGetTestPropertyCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmGetTestPropertyCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmGetTestPropertyCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmIfCommand.cxx b/Source/cmIfCommand.cxx
index 6f32861..c58ad06 100644
--- a/Source/cmIfCommand.cxx
+++ b/Source/cmIfCommand.cxx
@@ -11,8 +11,6 @@
#include "cmSystemTools.h"
#include "cmake.h"
-#include <memory>
-
static std::string cmIfCommandError(
std::vector<cmExpandedCommandArgument> const& args)
{
diff --git a/Source/cmIfCommand.h b/Source/cmIfCommand.h
index d34ed02..4a67760 100644
--- a/Source/cmIfCommand.h
+++ b/Source/cmIfCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
#include "cmFunctionBlocker.h"
#include "cmListFileCache.h"
@@ -38,7 +40,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmIfCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmIfCommand>();
+ }
/**
* This overrides the default InvokeInitialPass implementation.
diff --git a/Source/cmIncludeCommand.h b/Source/cmIncludeCommand.h
index 3b843b2..94d3fbd 100644
--- a/Source/cmIncludeCommand.h
+++ b/Source/cmIncludeCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmIncludeCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmIncludeCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmIncludeDirectoryCommand.h b/Source/cmIncludeDirectoryCommand.h
index 01d98db..4df94eb 100644
--- a/Source/cmIncludeDirectoryCommand.h
+++ b/Source/cmIncludeDirectoryCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmIncludeDirectoryCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmIncludeDirectoryCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmIncludeExternalMSProjectCommand.h b/Source/cmIncludeExternalMSProjectCommand.h
index 945acdc..9f76576 100644
--- a/Source/cmIncludeExternalMSProjectCommand.h
+++ b/Source/cmIncludeExternalMSProjectCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -25,7 +27,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmIncludeExternalMSProjectCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmIncludeExternalMSProjectCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmIncludeGuardCommand.h b/Source/cmIncludeGuardCommand.h
index eaad9b8..4306c4c 100644
--- a/Source/cmIncludeGuardCommand.h
+++ b/Source/cmIncludeGuardCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmIncludeGuardCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmIncludeGuardCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmIncludeRegularExpressionCommand.h b/Source/cmIncludeRegularExpressionCommand.h
index 8da991d..1723c8b 100644
--- a/Source/cmIncludeRegularExpressionCommand.h
+++ b/Source/cmIncludeRegularExpressionCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmIncludeRegularExpressionCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmIncludeRegularExpressionCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmInstallCommand.h b/Source/cmInstallCommand.h
index 202c438..28bf443 100644
--- a/Source/cmInstallCommand.h
+++ b/Source/cmInstallCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -25,7 +27,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmInstallCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmInstallCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmInstallFilesCommand.h b/Source/cmInstallFilesCommand.h
index a52f45e..e068b0e 100644
--- a/Source/cmInstallFilesCommand.h
+++ b/Source/cmInstallFilesCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmInstallFilesCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmInstallFilesCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmInstallProgramsCommand.h b/Source/cmInstallProgramsCommand.h
index 5c705eb..3242365 100644
--- a/Source/cmInstallProgramsCommand.h
+++ b/Source/cmInstallProgramsCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmInstallProgramsCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmInstallProgramsCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmInstallTargetsCommand.h b/Source/cmInstallTargetsCommand.h
index 9950fb7..55e69ba 100644
--- a/Source/cmInstallTargetsCommand.h
+++ b/Source/cmInstallTargetsCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -25,7 +27,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmInstallTargetsCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmInstallTargetsCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmLinkDirectoriesCommand.h b/Source/cmLinkDirectoriesCommand.h
index ae4fb7f..1a439de 100644
--- a/Source/cmLinkDirectoriesCommand.h
+++ b/Source/cmLinkDirectoriesCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -26,7 +28,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmLinkDirectoriesCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmLinkDirectoriesCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmLinkLibrariesCommand.h b/Source/cmLinkLibrariesCommand.h
index af25fba..484ab0a 100644
--- a/Source/cmLinkLibrariesCommand.h
+++ b/Source/cmLinkLibrariesCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -25,7 +27,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmLinkLibrariesCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmLinkLibrariesCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmListCommand.h b/Source/cmListCommand.h
index ea3d643..70c7f4e 100644
--- a/Source/cmListCommand.h
+++ b/Source/cmListCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -22,7 +24,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmListCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmListCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmLoadCacheCommand.h b/Source/cmLoadCacheCommand.h
index e0f6e4f..45e52f0 100644
--- a/Source/cmLoadCacheCommand.h
+++ b/Source/cmLoadCacheCommand.h
@@ -9,6 +9,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmLoadCacheCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmLoadCacheCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmLoadCommandCommand.cxx b/Source/cmLoadCommandCommand.cxx
index 69751b6..235dcd4 100644
--- a/Source/cmLoadCommandCommand.cxx
+++ b/Source/cmLoadCommandCommand.cxx
@@ -3,10 +3,14 @@
#include "cmLoadCommandCommand.h"
#include <signal.h>
+
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <utility>
+
+#include "cm_memory.hxx"
#include "cmCPluginAPI.cxx"
#include "cmCPluginAPI.h"
@@ -39,12 +43,12 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmLoadedCommand* newC = new cmLoadedCommand;
+ auto newC = cm::make_unique<cmLoadedCommand>();
// we must copy when we clone
memcpy(&newC->info, &this->info, sizeof(info));
- return newC;
+ return std::unique_ptr<cmLoadedCommand>(std::move(newC));
}
/**
@@ -237,9 +241,9 @@ bool cmLoadCommandCommand::InitialPass(std::vector<std::string> const& args,
// function blocker
if (initFunction) {
// create a function blocker and set it up
- cmLoadedCommand* f = new cmLoadedCommand();
+ auto f = cm::make_unique<cmLoadedCommand>();
(*initFunction)(&f->info);
- this->Makefile->GetState()->AddScriptedCommand(args[0], f);
+ this->Makefile->GetState()->AddScriptedCommand(args[0], std::move(f));
return true;
}
this->SetError("Attempt to load command failed. "
diff --git a/Source/cmLoadCommandCommand.h b/Source/cmLoadCommandCommand.h
index 021e6c7..d81cefb 100644
--- a/Source/cmLoadCommandCommand.h
+++ b/Source/cmLoadCommandCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -15,7 +17,10 @@ class cmExecutionStatus;
class cmLoadCommandCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmLoadCommandCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmLoadCommandCommand>();
+ }
bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus& status) override;
};
diff --git a/Source/cmMacroCommand.cxx b/Source/cmMacroCommand.cxx
index e9c6aea..3d553b7 100644
--- a/Source/cmMacroCommand.cxx
+++ b/Source/cmMacroCommand.cxx
@@ -6,6 +6,8 @@
#include <stdio.h>
#include <utility>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmExecutionStatus.h"
#include "cmMakefile.h"
@@ -21,15 +23,15 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- cmMacroHelperCommand* newC = new cmMacroHelperCommand;
+ auto newC = cm::make_unique<cmMacroHelperCommand>();
// we must copy when we clone
newC->Args = this->Args;
newC->Functions = this->Functions;
newC->FilePath = this->FilePath;
newC->Policies = this->Policies;
- return newC;
+ return std::unique_ptr<cmCommand>(std::move(newC));
}
/**
@@ -164,12 +166,12 @@ bool cmMacroFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
if (!this->Depth) {
mf.AppendProperty("MACROS", this->Args[0].c_str());
// create a new command and add it to cmake
- cmMacroHelperCommand* f = new cmMacroHelperCommand();
+ auto f = cm::make_unique<cmMacroHelperCommand>();
f->Args = this->Args;
f->Functions = this->Functions;
f->FilePath = this->GetStartingContext().FilePath;
mf.RecordPolicies(f->Policies);
- mf.GetState()->AddScriptedCommand(this->Args[0], f);
+ mf.GetState()->AddScriptedCommand(this->Args[0], std::move(f));
// remove the function blocker now that the macro is defined
mf.RemoveFunctionBlocker(this, lff);
return true;
diff --git a/Source/cmMacroCommand.h b/Source/cmMacroCommand.h
index b54ed66..3ebd959 100644
--- a/Source/cmMacroCommand.h
+++ b/Source/cmMacroCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
#include "cmFunctionBlocker.h"
#include "cmListFileCache.h"
@@ -34,7 +36,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmMacroCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmMacroCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmMakeDirectoryCommand.h b/Source/cmMakeDirectoryCommand.h
index d2637f3..b1fb49b 100644
--- a/Source/cmMakeDirectoryCommand.h
+++ b/Source/cmMakeDirectoryCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -27,7 +29,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmMakeDirectoryCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmMakeDirectoryCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 5f22a07..501ea69 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -118,7 +118,6 @@ cmMakefile::~cmMakefile()
cmDeleteAll(this->SourceFiles);
cmDeleteAll(this->Tests);
cmDeleteAll(this->ImportedTargetsOwned);
- cmDeleteAll(this->FinalPassCommands);
cmDeleteAll(this->FunctionBlockers);
cmDeleteAll(this->EvaluationFiles);
}
@@ -418,7 +417,7 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff,
}
} else if (pcmd->HasFinalPass()) {
// use the command
- this->FinalPassCommands.push_back(pcmd.release());
+ this->FinalPassCommands.push_back(std::move(pcmd));
}
}
} else {
@@ -776,8 +775,8 @@ void cmMakefile::FinalPass()
// give all the commands a chance to do something
// after the file has been parsed before generation
- for (cmCommand* fpCommand : this->FinalPassCommands) {
- fpCommand->FinalPass();
+ for (auto& command : this->FinalPassCommands) {
+ command->FinalPass();
}
// go through all configured files and see which ones still exist.
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index d0b70d9..1b4ead7 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -937,7 +937,7 @@ protected:
size_t ObjectLibrariesSourceGroupIndex;
#endif
- std::vector<cmCommand*> FinalPassCommands;
+ std::vector<std::unique_ptr<cmCommand>> FinalPassCommands;
cmGlobalGenerator* GlobalGenerator;
bool IsFunctionBlocked(const cmListFileFunction& lff,
cmExecutionStatus& status);
diff --git a/Source/cmMarkAsAdvancedCommand.h b/Source/cmMarkAsAdvancedCommand.h
index 5dd198f..e367c46 100644
--- a/Source/cmMarkAsAdvancedCommand.h
+++ b/Source/cmMarkAsAdvancedCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmMarkAsAdvancedCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmMarkAsAdvancedCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmMathCommand.h b/Source/cmMathCommand.h
index 0c6c76b..23633d3 100644
--- a/Source/cmMathCommand.h
+++ b/Source/cmMathCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -19,7 +21,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmMathCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmMathCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmMessageCommand.h b/Source/cmMessageCommand.h
index 819ebda..ef89d59 100644
--- a/Source/cmMessageCommand.h
+++ b/Source/cmMessageCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -22,7 +24,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmMessageCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmMessageCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmOptionCommand.h b/Source/cmOptionCommand.h
index 34e0e6f..eddab03 100644
--- a/Source/cmOptionCommand.h
+++ b/Source/cmOptionCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmOptionCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmOptionCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmOutputRequiredFilesCommand.h b/Source/cmOutputRequiredFilesCommand.h
index 09e622b..faffabd 100644
--- a/Source/cmOutputRequiredFilesCommand.h
+++ b/Source/cmOutputRequiredFilesCommand.h
@@ -10,6 +10,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmDependInformation;
@@ -18,7 +20,10 @@ class cmExecutionStatus;
class cmOutputRequiredFilesCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmOutputRequiredFilesCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmOutputRequiredFilesCommand>();
+ }
bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus& status) override;
diff --git a/Source/cmParseArgumentsCommand.h b/Source/cmParseArgumentsCommand.h
index b8ba61d..692ea64 100644
--- a/Source/cmParseArgumentsCommand.h
+++ b/Source/cmParseArgumentsCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -21,7 +23,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmParseArgumentsCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmParseArgumentsCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmProjectCommand.h b/Source/cmProjectCommand.h
index f1d03e7..8b9bcc8 100644
--- a/Source/cmProjectCommand.h
+++ b/Source/cmProjectCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -26,7 +28,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmProjectCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmProjectCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmQTWrapCPPCommand.h b/Source/cmQTWrapCPPCommand.h
index c1dcd54..88a2210 100644
--- a/Source/cmQTWrapCPPCommand.h
+++ b/Source/cmQTWrapCPPCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmQTWrapCPPCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmQTWrapCPPCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmQTWrapUICommand.h b/Source/cmQTWrapUICommand.h
index 15cab40..6a346d4 100644
--- a/Source/cmQTWrapUICommand.h
+++ b/Source/cmQTWrapUICommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmQTWrapUICommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmQTWrapUICommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmRemoveCommand.h b/Source/cmRemoveCommand.h
index 7b11849..088d8ad 100644
--- a/Source/cmRemoveCommand.h
+++ b/Source/cmRemoveCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmRemoveCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmRemoveCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmRemoveDefinitionsCommand.h b/Source/cmRemoveDefinitionsCommand.h
index a5cb204..85d01d4 100644
--- a/Source/cmRemoveDefinitionsCommand.h
+++ b/Source/cmRemoveDefinitionsCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -25,7 +27,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmRemoveDefinitionsCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmRemoveDefinitionsCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmReturnCommand.h b/Source/cmReturnCommand.h
index ef39614..e9264d2 100644
--- a/Source/cmReturnCommand.h
+++ b/Source/cmReturnCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmReturnCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmReturnCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmSeparateArgumentsCommand.h b/Source/cmSeparateArgumentsCommand.h
index 988ad23..76e2002 100644
--- a/Source/cmSeparateArgumentsCommand.h
+++ b/Source/cmSeparateArgumentsCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmSeparateArgumentsCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmSeparateArgumentsCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmSetCommand.h b/Source/cmSetCommand.h
index 76e3eae..1c5a435 100644
--- a/Source/cmSetCommand.h
+++ b/Source/cmSetCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmSetCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmSetCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmSetDirectoryPropertiesCommand.h b/Source/cmSetDirectoryPropertiesCommand.h
index 473347c..5416127 100644
--- a/Source/cmSetDirectoryPropertiesCommand.h
+++ b/Source/cmSetDirectoryPropertiesCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -16,7 +18,10 @@ class cmMakefile;
class cmSetDirectoryPropertiesCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmSetDirectoryPropertiesCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmSetDirectoryPropertiesCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmSetPropertyCommand.h b/Source/cmSetPropertyCommand.h
index f1126bb..4051e48 100644
--- a/Source/cmSetPropertyCommand.h
+++ b/Source/cmSetPropertyCommand.h
@@ -9,6 +9,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -22,7 +24,10 @@ class cmSetPropertyCommand : public cmCommand
public:
cmSetPropertyCommand();
- cmCommand* Clone() override { return new cmSetPropertyCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmSetPropertyCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmSetSourceFilesPropertiesCommand.h b/Source/cmSetSourceFilesPropertiesCommand.h
index afb19f6..6fd6c41 100644
--- a/Source/cmSetSourceFilesPropertiesCommand.h
+++ b/Source/cmSetSourceFilesPropertiesCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -16,7 +18,10 @@ class cmMakefile;
class cmSetSourceFilesPropertiesCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmSetSourceFilesPropertiesCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmSetSourceFilesPropertiesCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmSetTargetPropertiesCommand.h b/Source/cmSetTargetPropertiesCommand.h
index c9755da..7e4606e 100644
--- a/Source/cmSetTargetPropertiesCommand.h
+++ b/Source/cmSetTargetPropertiesCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -16,7 +18,10 @@ class cmMakefile;
class cmSetTargetPropertiesCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmSetTargetPropertiesCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmSetTargetPropertiesCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmSetTestsPropertiesCommand.h b/Source/cmSetTestsPropertiesCommand.h
index 84b2645..d73e95a 100644
--- a/Source/cmSetTestsPropertiesCommand.h
+++ b/Source/cmSetTestsPropertiesCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -16,7 +18,10 @@ class cmMakefile;
class cmSetTestsPropertiesCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmSetTestsPropertiesCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmSetTestsPropertiesCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmSiteNameCommand.h b/Source/cmSiteNameCommand.h
index 2d8dc17..0190abb 100644
--- a/Source/cmSiteNameCommand.h
+++ b/Source/cmSiteNameCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmSiteNameCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmSiteNameCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmSourceGroupCommand.h b/Source/cmSourceGroupCommand.h
index ec5ad32..eec4ec0 100644
--- a/Source/cmSourceGroupCommand.h
+++ b/Source/cmSourceGroupCommand.h
@@ -9,6 +9,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -25,7 +27,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmSourceGroupCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmSourceGroupCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmState.cxx b/Source/cmState.cxx
index 878d5b6..9748cf5 100644
--- a/Source/cmState.cxx
+++ b/Source/cmState.cxx
@@ -6,6 +6,7 @@
#include <algorithm>
#include <assert.h>
#include <string.h>
+#include <type_traits>
#include <utility>
#include "cm_memory.hxx"
@@ -29,11 +30,7 @@ cmState::cmState()
this->GlobVerificationManager = cm::make_unique<cmGlobVerificationManager>();
}
-cmState::~cmState()
-{
- cmDeleteAll(this->BuiltinCommands);
- cmDeleteAll(this->ScriptedCommands);
-}
+cmState::~cmState() = default;
const char* cmState::GetTargetTypeName(cmStateEnums::TargetType targetType)
{
@@ -421,50 +418,55 @@ void cmState::SetIsGeneratorMultiConfig(bool b)
this->IsGeneratorMultiConfig = b;
}
-void cmState::AddBuiltinCommand(std::string const& name, cmCommand* command)
+void cmState::AddBuiltinCommand(std::string const& name,
+ std::unique_ptr<cmCommand> command)
{
assert(name == cmSystemTools::LowerCase(name));
assert(this->BuiltinCommands.find(name) == this->BuiltinCommands.end());
- this->BuiltinCommands.insert(std::make_pair(name, command));
+ this->BuiltinCommands.insert(
+ std::map<std::string, std::unique_ptr<cmCommand>>::value_type(
+ name, std::move(command)));
}
-void cmState::AddDisallowedCommand(std::string const& name, cmCommand* command,
+void cmState::AddDisallowedCommand(std::string const& name,
+ std::unique_ptr<cmCommand> command,
cmPolicies::PolicyID policy,
const char* message)
{
- this->AddBuiltinCommand(name,
- new cmDisallowedCommand(command, policy, message));
+ this->AddBuiltinCommand(
+ name,
+ cm::make_unique<cmDisallowedCommand>(std::move(command), policy, message));
}
void cmState::AddUnexpectedCommand(std::string const& name, const char* error)
{
- this->AddBuiltinCommand(name, new cmUnexpectedCommand(name, error));
+ this->AddBuiltinCommand(name,
+ cm::make_unique<cmUnexpectedCommand>(name, error));
}
-void cmState::AddScriptedCommand(std::string const& name, cmCommand* command)
+void cmState::AddScriptedCommand(std::string const& name,
+ std::unique_ptr<cmCommand> command)
{
std::string sName = cmSystemTools::LowerCase(name);
// if the command already exists, give a new name to the old command.
if (cmCommand* oldCmd = this->GetCommand(sName)) {
std::string const newName = "_" + sName;
- std::map<std::string, cmCommand*>::iterator pos =
- this->ScriptedCommands.find(newName);
+ auto pos = this->ScriptedCommands.find(newName);
if (pos != this->ScriptedCommands.end()) {
- delete pos->second;
this->ScriptedCommands.erase(pos);
}
this->ScriptedCommands.insert(std::make_pair(newName, oldCmd->Clone()));
}
// if the command already exists, free the old one
- std::map<std::string, cmCommand*>::iterator pos =
- this->ScriptedCommands.find(sName);
+ auto pos = this->ScriptedCommands.find(sName);
if (pos != this->ScriptedCommands.end()) {
- delete pos->second;
this->ScriptedCommands.erase(pos);
}
- this->ScriptedCommands.insert(std::make_pair(sName, command));
+ this->ScriptedCommands.insert(
+ std::map<std::string, std::unique_ptr<cmCommand>>::value_type(
+ sName, std::move(command)));
}
cmCommand* cmState::GetCommand(std::string const& name) const
@@ -474,14 +476,13 @@ cmCommand* cmState::GetCommand(std::string const& name) const
cmCommand* cmState::GetCommandByExactName(std::string const& name) const
{
- std::map<std::string, cmCommand*>::const_iterator pos;
- pos = this->ScriptedCommands.find(name);
+ auto pos = this->ScriptedCommands.find(name);
if (pos != this->ScriptedCommands.end()) {
- return pos->second;
+ return pos->second.get();
}
pos = this->BuiltinCommands.find(name);
if (pos != this->BuiltinCommands.end()) {
- return pos->second;
+ return pos->second.get();
}
return nullptr;
}
@@ -506,16 +507,13 @@ std::vector<std::string> cmState::GetCommandNames() const
void cmState::RemoveBuiltinCommand(std::string const& name)
{
assert(name == cmSystemTools::LowerCase(name));
- std::map<std::string, cmCommand*>::iterator i =
- this->BuiltinCommands.find(name);
+ auto i = this->BuiltinCommands.find(name);
assert(i != this->BuiltinCommands.end());
- delete i->second;
this->BuiltinCommands.erase(i);
}
void cmState::RemoveUserDefinedCommands()
{
- cmDeleteAll(this->ScriptedCommands);
this->ScriptedCommands.clear();
}
diff --git a/Source/cmState.h b/Source/cmState.h
index 0649ace..7e88030 100644
--- a/Source/cmState.h
+++ b/Source/cmState.h
@@ -146,11 +146,14 @@ public:
// Returns a command from its name, or nullptr
cmCommand* GetCommandByExactName(std::string const& name) const;
- void AddBuiltinCommand(std::string const& name, cmCommand* command);
- void AddDisallowedCommand(std::string const& name, cmCommand* command,
+ void AddBuiltinCommand(std::string const& name,
+ std::unique_ptr<cmCommand> command);
+ void AddDisallowedCommand(std::string const& name,
+ std::unique_ptr<cmCommand> command,
cmPolicies::PolicyID policy, const char* message);
void AddUnexpectedCommand(std::string const& name, const char* error);
- void AddScriptedCommand(std::string const& name, cmCommand* command);
+ void AddScriptedCommand(std::string const& name,
+ std::unique_ptr<cmCommand> command);
void RemoveBuiltinCommand(std::string const& name);
void RemoveUserDefinedCommands();
std::vector<std::string> GetCommandNames() const;
@@ -209,8 +212,8 @@ private:
std::map<cmProperty::ScopeType, cmPropertyDefinitionMap> PropertyDefinitions;
std::vector<std::string> EnabledLanguages;
- std::map<std::string, cmCommand*> BuiltinCommands;
- std::map<std::string, cmCommand*> ScriptedCommands;
+ std::map<std::string, std::unique_ptr<cmCommand>> BuiltinCommands;
+ std::map<std::string, std::unique_ptr<cmCommand>> ScriptedCommands;
cmPropertyMap GlobalProperties;
std::unique_ptr<cmCacheManager> CacheManager;
std::unique_ptr<cmGlobVerificationManager> GlobVerificationManager;
diff --git a/Source/cmStringCommand.cxx b/Source/cmStringCommand.cxx
index 10ccac0..4ad0870 100644
--- a/Source/cmStringCommand.cxx
+++ b/Source/cmStringCommand.cxx
@@ -8,7 +8,6 @@
#include <algorithm>
#include <ctype.h>
#include <iterator>
-#include <memory>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
diff --git a/Source/cmStringCommand.h b/Source/cmStringCommand.h
index acde605..f48ea17 100644
--- a/Source/cmStringCommand.h
+++ b/Source/cmStringCommand.h
@@ -9,6 +9,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmStringCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmStringCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmSubdirCommand.h b/Source/cmSubdirCommand.h
index adab757..3499c46 100644
--- a/Source/cmSubdirCommand.h
+++ b/Source/cmSubdirCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -25,7 +27,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmSubdirCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmSubdirCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmSubdirDependsCommand.h b/Source/cmSubdirDependsCommand.h
index 2db28c6..64c28b9 100644
--- a/Source/cmSubdirDependsCommand.h
+++ b/Source/cmSubdirDependsCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -15,7 +17,10 @@ class cmExecutionStatus;
class cmSubdirDependsCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmSubdirDependsCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmSubdirDependsCommand>();
+ }
bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus& status) override;
};
diff --git a/Source/cmTargetCompileDefinitionsCommand.h b/Source/cmTargetCompileDefinitionsCommand.h
index d41483a..25af21d 100644
--- a/Source/cmTargetCompileDefinitionsCommand.h
+++ b/Source/cmTargetCompileDefinitionsCommand.h
@@ -8,9 +8,11 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
+#include "cmCommand.h"
#include "cmTargetPropCommandBase.h"
-class cmCommand;
class cmExecutionStatus;
class cmTarget;
@@ -20,7 +22,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmTargetCompileDefinitionsCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmTargetCompileDefinitionsCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmTargetCompileFeaturesCommand.h b/Source/cmTargetCompileFeaturesCommand.h
index 45240a5..07948fa 100644
--- a/Source/cmTargetCompileFeaturesCommand.h
+++ b/Source/cmTargetCompileFeaturesCommand.h
@@ -8,15 +8,20 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
+#include "cmCommand.h"
#include "cmTargetPropCommandBase.h"
-class cmCommand;
class cmExecutionStatus;
class cmTarget;
class cmTargetCompileFeaturesCommand : public cmTargetPropCommandBase
{
- cmCommand* Clone() override { return new cmTargetCompileFeaturesCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmTargetCompileFeaturesCommand>();
+ }
bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus& status) override;
diff --git a/Source/cmTargetCompileOptionsCommand.h b/Source/cmTargetCompileOptionsCommand.h
index 6fb151a..a571cfb 100644
--- a/Source/cmTargetCompileOptionsCommand.h
+++ b/Source/cmTargetCompileOptionsCommand.h
@@ -8,9 +8,11 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
+#include "cmCommand.h"
#include "cmTargetPropCommandBase.h"
-class cmCommand;
class cmExecutionStatus;
class cmTarget;
@@ -20,7 +22,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmTargetCompileOptionsCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmTargetCompileOptionsCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmTargetIncludeDirectoriesCommand.h b/Source/cmTargetIncludeDirectoriesCommand.h
index 57bf8fc..6defab2 100644
--- a/Source/cmTargetIncludeDirectoriesCommand.h
+++ b/Source/cmTargetIncludeDirectoriesCommand.h
@@ -8,9 +8,11 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
+#include "cmCommand.h"
#include "cmTargetPropCommandBase.h"
-class cmCommand;
class cmExecutionStatus;
class cmTarget;
@@ -20,7 +22,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmTargetIncludeDirectoriesCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmTargetIncludeDirectoriesCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmTargetLinkDirectoriesCommand.h b/Source/cmTargetLinkDirectoriesCommand.h
index 52c75a0..a2fcfa9 100644
--- a/Source/cmTargetLinkDirectoriesCommand.h
+++ b/Source/cmTargetLinkDirectoriesCommand.h
@@ -8,9 +8,11 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
+#include "cmCommand.h"
#include "cmTargetPropCommandBase.h"
-class cmCommand;
class cmExecutionStatus;
class cmTarget;
@@ -20,7 +22,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmTargetLinkDirectoriesCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmTargetLinkDirectoriesCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmTargetLinkLibrariesCommand.h b/Source/cmTargetLinkLibrariesCommand.h
index 54f8cf4..6698ce0 100644
--- a/Source/cmTargetLinkLibrariesCommand.h
+++ b/Source/cmTargetLinkLibrariesCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
#include "cmTargetLinkLibraryType.h"
@@ -30,7 +32,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmTargetLinkLibrariesCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmTargetLinkLibrariesCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmTargetLinkOptionsCommand.h b/Source/cmTargetLinkOptionsCommand.h
index a1fc9fc..3710739 100644
--- a/Source/cmTargetLinkOptionsCommand.h
+++ b/Source/cmTargetLinkOptionsCommand.h
@@ -8,9 +8,11 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
+#include "cmCommand.h"
#include "cmTargetPropCommandBase.h"
-class cmCommand;
class cmExecutionStatus;
class cmTarget;
@@ -20,7 +22,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmTargetLinkOptionsCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmTargetLinkOptionsCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmTargetSourcesCommand.h b/Source/cmTargetSourcesCommand.h
index b01e3ca..90fd45f 100644
--- a/Source/cmTargetSourcesCommand.h
+++ b/Source/cmTargetSourcesCommand.h
@@ -8,9 +8,11 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
+#include "cmCommand.h"
#include "cmTargetPropCommandBase.h"
-class cmCommand;
class cmExecutionStatus;
class cmTarget;
@@ -20,7 +22,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmTargetSourcesCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmTargetSourcesCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmTryCompileCommand.h b/Source/cmTryCompileCommand.h
index 8237878..ec9f8b8 100644
--- a/Source/cmTryCompileCommand.h
+++ b/Source/cmTryCompileCommand.h
@@ -8,9 +8,11 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
+#include "cmCommand.h"
#include "cmCoreTryCompile.h"
-class cmCommand;
class cmExecutionStatus;
/** \class cmTryCompileCommand
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmTryCompileCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmTryCompileCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmTryRunCommand.h b/Source/cmTryRunCommand.h
index c54622c..bacfcdb 100644
--- a/Source/cmTryRunCommand.h
+++ b/Source/cmTryRunCommand.h
@@ -8,9 +8,11 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
+#include "cmCommand.h"
#include "cmCoreTryCompile.h"
-class cmCommand;
class cmExecutionStatus;
/** \class cmTryRunCommand
@@ -24,7 +26,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmTryRunCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmTryRunCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmUVProcessChain.cxx b/Source/cmUVProcessChain.cxx
index fbd5634..56d6c09 100644
--- a/Source/cmUVProcessChain.cxx
+++ b/Source/cmUVProcessChain.cxx
@@ -2,7 +2,6 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmUVProcessChain.h"
-#include "cmAlgorithms.h"
#include "cmGetPipes.h"
#include "cmUVHandlePtr.h"
#include "cmUVStreambuf.h"
@@ -10,6 +9,7 @@
#include <assert.h>
+#include <istream> // IWYU pragma: keep
#include <iterator>
#include <utility>
diff --git a/Source/cmUnexpectedCommand.h b/Source/cmUnexpectedCommand.h
index 33d6bdc..6e4cee5 100644
--- a/Source/cmUnexpectedCommand.h
+++ b/Source/cmUnexpectedCommand.h
@@ -9,6 +9,8 @@
#include <utility>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -22,9 +24,9 @@ public:
{
}
- cmCommand* Clone() override
+ std::unique_ptr<cmCommand> Clone() override
{
- return new cmUnexpectedCommand(this->Name, this->Error);
+ return cm::make_unique<cmUnexpectedCommand>(this->Name, this->Error);
}
bool InitialPass(std::vector<std::string> const& args,
diff --git a/Source/cmUnsetCommand.h b/Source/cmUnsetCommand.h
index 4e1208a..9b78d44 100644
--- a/Source/cmUnsetCommand.h
+++ b/Source/cmUnsetCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmUnsetCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmUnsetCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Source/cmUseMangledMesaCommand.h b/Source/cmUseMangledMesaCommand.h
index e2f1d9b..1c01596 100644
--- a/Source/cmUseMangledMesaCommand.h
+++ b/Source/cmUseMangledMesaCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -15,7 +17,10 @@ class cmExecutionStatus;
class cmUseMangledMesaCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmUseMangledMesaCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmUseMangledMesaCommand>();
+ }
bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus& status) override;
diff --git a/Source/cmUtilitySourceCommand.h b/Source/cmUtilitySourceCommand.h
index 165ecef..cef7fed 100644
--- a/Source/cmUtilitySourceCommand.h
+++ b/Source/cmUtilitySourceCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -15,7 +17,10 @@ class cmExecutionStatus;
class cmUtilitySourceCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmUtilitySourceCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmUtilitySourceCommand>();
+ }
bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus& status) override;
};
diff --git a/Source/cmVariableRequiresCommand.h b/Source/cmVariableRequiresCommand.h
index 94970c5..38e7490 100644
--- a/Source/cmVariableRequiresCommand.h
+++ b/Source/cmVariableRequiresCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -15,7 +17,10 @@ class cmExecutionStatus;
class cmVariableRequiresCommand : public cmCommand
{
public:
- cmCommand* Clone() override { return new cmVariableRequiresCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmVariableRequiresCommand>();
+ }
bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus& status) override;
};
diff --git a/Source/cmVariableWatchCommand.h b/Source/cmVariableWatchCommand.h
index 6a8115d..0dbb0cb 100644
--- a/Source/cmVariableWatchCommand.h
+++ b/Source/cmVariableWatchCommand.h
@@ -9,6 +9,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -23,7 +25,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmVariableWatchCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmVariableWatchCommand>();
+ }
//! Default constructor
cmVariableWatchCommand();
diff --git a/Source/cmWhileCommand.cxx b/Source/cmWhileCommand.cxx
index 0d3bdf8..31a878d 100644
--- a/Source/cmWhileCommand.cxx
+++ b/Source/cmWhileCommand.cxx
@@ -9,8 +9,6 @@
#include "cmMessageType.h"
#include "cmSystemTools.h"
-#include <memory>
-
cmWhileFunctionBlocker::cmWhileFunctionBlocker(cmMakefile* mf)
: Makefile(mf)
, Depth(0)
diff --git a/Source/cmWhileCommand.h b/Source/cmWhileCommand.h
index 6f6d405..857d1c8 100644
--- a/Source/cmWhileCommand.h
+++ b/Source/cmWhileCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
#include "cmFunctionBlocker.h"
#include "cmListFileCache.h"
@@ -39,7 +41,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmWhileCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmWhileCommand>();
+ }
/**
* This overrides the default InvokeInitialPass implementation.
diff --git a/Source/cmWriteFileCommand.h b/Source/cmWriteFileCommand.h
index 9028f84..3961898 100644
--- a/Source/cmWriteFileCommand.h
+++ b/Source/cmWriteFileCommand.h
@@ -8,6 +8,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmCommand.h"
class cmExecutionStatus;
@@ -22,7 +24,10 @@ public:
/**
* This is a virtual constructor for the command.
*/
- cmCommand* Clone() override { return new cmWriteFileCommand; }
+ std::unique_ptr<cmCommand> Clone() override
+ {
+ return cm::make_unique<cmWriteFileCommand>();
+ }
/**
* This is called when the command is first encountered in
diff --git a/Tests/CMakeLib/testUVProcessChain.cxx b/Tests/CMakeLib/testUVProcessChain.cxx
index 2c1202e..63c9943 100644
--- a/Tests/CMakeLib/testUVProcessChain.cxx
+++ b/Tests/CMakeLib/testUVProcessChain.cxx
@@ -9,7 +9,6 @@
#include <algorithm>
#include <functional>
#include <iostream>
-#include <memory>
#include <sstream>
#include <string>
#include <vector>
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=d9b2c7dae242868f13fc366773fb09448da26e8d
commit d9b2c7dae242868f13fc366773fb09448da26e8d
Author: Marc Chevrier <marc.chevrier at gmail.com>
AuthorDate: Tue Jul 2 11:08:04 2019 +0200
Commit: Marc Chevrier <marc.chevrier at gmail.com>
CommitDate: Sun Jul 14 15:37:30 2019 +0200
Introduce memory management helper: cm_memory.hxx
diff --git a/Source/CPack/cmCPackExternalGenerator.cxx b/Source/CPack/cmCPackExternalGenerator.cxx
index 9dc9853..b4c7a5a 100644
--- a/Source/CPack/cmCPackExternalGenerator.cxx
+++ b/Source/CPack/cmCPackExternalGenerator.cxx
@@ -2,7 +2,6 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmCPackExternalGenerator.h"
-#include "cmAlgorithms.h"
#include "cmCPackComponentGroup.h"
#include "cmCPackLog.h"
#include "cmMakefile.h"
@@ -17,6 +16,8 @@
#include <utility>
#include <vector>
+#include "cm_memory.hxx"
+
int cmCPackExternalGenerator::InitializeInternal()
{
this->SetOption("CPACK_EXTERNAL_KNOWN_VERSIONS", "1.0");
diff --git a/Source/CTest/cmCTestRunTest.cxx b/Source/CTest/cmCTestRunTest.cxx
index b865cab..f9ac1eb 100644
--- a/Source/CTest/cmCTestRunTest.cxx
+++ b/Source/CTest/cmCTestRunTest.cxx
@@ -11,7 +11,6 @@
#include "cmsys/RegularExpression.hxx"
#include <chrono>
-#include <cmAlgorithms.h>
#include <cstdint>
#include <cstring>
#include <iomanip>
@@ -20,6 +19,8 @@
#include <stdio.h>
#include <utility>
+#include "cm_memory.hxx"
+
cmCTestRunTest::cmCTestRunTest(cmCTestMultiProcessHandler& multiHandler)
: MultiTestHandler(multiHandler)
{
diff --git a/Source/CTest/cmCTestUpdateHandler.cxx b/Source/CTest/cmCTestUpdateHandler.cxx
index fb97e9b..d80b5a5 100644
--- a/Source/CTest/cmCTestUpdateHandler.cxx
+++ b/Source/CTest/cmCTestUpdateHandler.cxx
@@ -2,7 +2,6 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmCTestUpdateHandler.h"
-#include "cmAlgorithms.h"
#include "cmCLocaleEnvironmentScope.h"
#include "cmCTest.h"
#include "cmCTestBZR.h"
@@ -18,9 +17,10 @@
#include "cmXMLWriter.h"
#include <chrono>
-#include <memory>
#include <sstream>
+#include "cm_memory.hxx"
+
static const char* cmCTestUpdateHandlerUpdateStrings[] = {
"Unknown", "CVS", "SVN", "BZR", "GIT", "HG", "P4"
};
diff --git a/Source/cmAlgorithms.h b/Source/cmAlgorithms.h
index d1e32b0..d153076 100644
--- a/Source/cmAlgorithms.h
+++ b/Source/cmAlgorithms.h
@@ -11,7 +11,6 @@
#include <algorithm>
#include <functional>
#include <iterator>
-#include <memory>
#include <sstream>
#include <string.h>
#include <string>
@@ -340,20 +339,6 @@ inline void cmStripSuffixIfExists(std::string& str, const std::string& suffix)
namespace cm {
-#if defined(CMake_HAVE_CXX_MAKE_UNIQUE)
-
-using std::make_unique;
-
-#else
-
-template <typename T, typename... Args>
-std::unique_ptr<T> make_unique(Args&&... args)
-{
- return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-}
-
-#endif
-
#if __cplusplus >= 201703L || defined(_MSVC_LANG) && _MSVC_LANG >= 201703L
using std::size;
diff --git a/Source/cmBinUtilsLinuxELFLinker.cxx b/Source/cmBinUtilsLinuxELFLinker.cxx
index 4fb15f2..86846cb 100644
--- a/Source/cmBinUtilsLinuxELFLinker.cxx
+++ b/Source/cmBinUtilsLinuxELFLinker.cxx
@@ -2,7 +2,7 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmBinUtilsLinuxELFLinker.h"
-#include "cmAlgorithms.h"
+
#include "cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool.h"
#include "cmLDConfigLDConfigTool.h"
#include "cmMakefile.h"
@@ -12,9 +12,10 @@
#include <cmsys/RegularExpression.hxx>
-#include <memory>
#include <sstream>
+#include "cm_memory.hxx"
+
static std::string ReplaceOrigin(const std::string& rpath,
const std::string& origin)
{
diff --git a/Source/cmBinUtilsMacOSMachOLinker.cxx b/Source/cmBinUtilsMacOSMachOLinker.cxx
index e219847..ac93155 100644
--- a/Source/cmBinUtilsMacOSMachOLinker.cxx
+++ b/Source/cmBinUtilsMacOSMachOLinker.cxx
@@ -12,6 +12,8 @@
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
cmBinUtilsMacOSMachOLinker::cmBinUtilsMacOSMachOLinker(
cmRuntimeDependencyArchive* archive)
: cmBinUtilsLinker(archive)
diff --git a/Source/cmBinUtilsWindowsPELinker.cxx b/Source/cmBinUtilsWindowsPELinker.cxx
index 796e9ed..31602c4 100644
--- a/Source/cmBinUtilsWindowsPELinker.cxx
+++ b/Source/cmBinUtilsWindowsPELinker.cxx
@@ -2,16 +2,17 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmBinUtilsWindowsPELinker.h"
-#include "cmAlgorithms.h"
+
#include "cmBinUtilsWindowsPEDumpbinGetRuntimeDependenciesTool.h"
#include "cmBinUtilsWindowsPEObjdumpGetRuntimeDependenciesTool.h"
#include "cmRuntimeDependencyArchive.h"
#include "cmSystemTools.h"
-#include <memory>
#include <sstream>
#include <vector>
+#include "cm_memory.hxx"
+
#ifdef _WIN32
# include <windows.h>
#endif
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index afdc039..83e3eff 100644
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@@ -15,7 +15,6 @@
#include <ctype.h>
#include <iostream>
#include <map>
-#include <memory>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
@@ -30,6 +29,8 @@
# include <unistd.h> // IWYU pragma: keep
#endif
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmCTestBuildAndTestHandler.h"
#include "cmCTestBuildHandler.h"
diff --git a/Source/cmComputeLinkDepends.cxx b/Source/cmComputeLinkDepends.cxx
index a7618c7..54fc54c 100644
--- a/Source/cmComputeLinkDepends.cxx
+++ b/Source/cmComputeLinkDepends.cxx
@@ -23,6 +23,8 @@
#include <string.h>
#include <utility>
+#include "cm_memory.hxx"
+
/*
This file computes an ordered list of link items to use when linking a
diff --git a/Source/cmCryptoHash.cxx b/Source/cmCryptoHash.cxx
index 4310eed..5e919af 100644
--- a/Source/cmCryptoHash.cxx
+++ b/Source/cmCryptoHash.cxx
@@ -2,13 +2,13 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmCryptoHash.h"
-#include "cmAlgorithms.h"
#include "cm_kwiml.h"
#include "cm_rhash.h"
#include "cmsys/FStream.hxx"
+
#include <string.h>
-#include <memory>
+#include "cm_memory.hxx"
static unsigned int const cmCryptoHashAlgoToId[] = {
/* clang-format needs this comment to break after the opening brace */
diff --git a/Source/cmExportFileGenerator.cxx b/Source/cmExportFileGenerator.cxx
index e1c098d..29afc9f 100644
--- a/Source/cmExportFileGenerator.cxx
+++ b/Source/cmExportFileGenerator.cxx
@@ -20,11 +20,12 @@
#include "cmsys/FStream.hxx"
#include <assert.h>
-#include <memory>
#include <sstream>
#include <string.h>
#include <utility>
+#include "cm_memory.hxx"
+
static std::string cmExportFileGeneratorEscape(std::string const& str)
{
// Escape a property value for writing into a .cmake file.
diff --git a/Source/cmExportLibraryDependenciesCommand.cxx b/Source/cmExportLibraryDependenciesCommand.cxx
index 2e86533..87ef2a9 100644
--- a/Source/cmExportLibraryDependenciesCommand.cxx
+++ b/Source/cmExportLibraryDependenciesCommand.cxx
@@ -4,10 +4,10 @@
#include "cmsys/FStream.hxx"
#include <map>
-#include <memory>
#include <utility>
-#include "cmAlgorithms.h"
+#include "cm_memory.hxx"
+
#include "cmGeneratedFileStream.h"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx
index dfba910..9871f49 100644
--- a/Source/cmFileCommand.cxx
+++ b/Source/cmFileCommand.cxx
@@ -13,7 +13,6 @@
#include <cmath>
#include <ctype.h>
#include <map>
-#include <memory>
#include <set>
#include <sstream>
#include <stdio.h>
@@ -21,6 +20,8 @@
#include <utility>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmArgumentParser.h"
#include "cmCryptoHash.h"
diff --git a/Source/cmFileTimes.cxx b/Source/cmFileTimes.cxx
index fd4f679..3824e9b 100644
--- a/Source/cmFileTimes.cxx
+++ b/Source/cmFileTimes.cxx
@@ -2,11 +2,12 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmFileTimes.h"
-#include "cmAlgorithms.h"
#include "cm_sys_stat.h"
#include <utility>
+#include "cm_memory.hxx"
+
#if defined(_WIN32)
# include "cmSystemTools.h"
# include <windows.h>
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index 783b5f6..85546bf 100644
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@@ -13,12 +13,13 @@
#include <deque>
#include <functional>
#include <iterator>
-#include <memory>
#include <sstream>
#include <stdio.h>
#include <string.h>
#include <utility>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
diff --git a/Source/cmForEachCommand.cxx b/Source/cmForEachCommand.cxx
index 7f189d6..94c1b1a 100644
--- a/Source/cmForEachCommand.cxx
+++ b/Source/cmForEachCommand.cxx
@@ -2,12 +2,12 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmForEachCommand.h"
-#include <memory>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
-#include "cmAlgorithms.h"
+#include "cm_memory.hxx"
+
#include "cmExecutionStatus.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx
index 98e8339..69a7da9 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -9,10 +9,11 @@
#include <algorithm>
#include <ctype.h>
#include <iterator>
-#include <memory>
#include <sstream>
#include <stdio.h>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmDocumentationEntry.h"
#include "cmFortranParser.h"
diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx
index 93f5482..35af0e1 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.cxx
+++ b/Source/cmGlobalUnixMakefileGenerator3.cxx
@@ -4,10 +4,11 @@
#include <algorithm>
#include <functional>
-#include <memory>
#include <sstream>
#include <utility>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmDocumentationEntry.h"
#include "cmGeneratedFileStream.h"
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index 78e8f30..d99a906 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -5,11 +5,12 @@
#include "cmsys/RegularExpression.hxx"
#include <assert.h>
#include <iomanip>
-#include <memory>
#include <sstream>
#include <stdio.h>
#include <string.h>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmComputeLinkInformation.h"
#include "cmCustomCommand.h"
diff --git a/Source/cmListCommand.cxx b/Source/cmListCommand.cxx
index e9a4a6f..a2e665f 100644
--- a/Source/cmListCommand.cxx
+++ b/Source/cmListCommand.cxx
@@ -7,7 +7,6 @@
#include <assert.h>
#include <functional>
#include <iterator>
-#include <memory>
#include <set>
#include <sstream>
#include <stdexcept>
@@ -16,6 +15,8 @@
#include <utility>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmGeneratorExpression.h"
#include "cmMakefile.h"
diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx
index 1b4f428..1ec1fd9 100644
--- a/Source/cmLocalUnixMakefileGenerator3.cxx
+++ b/Source/cmLocalUnixMakefileGenerator3.cxx
@@ -5,11 +5,12 @@
#include "cmsys/FStream.hxx"
#include "cmsys/Terminal.h"
#include <algorithm>
-#include <memory>
#include <sstream>
#include <stdio.h>
#include <utility>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmCustomCommand.h" // IWYU pragma: keep
#include "cmCustomCommandGenerator.h"
diff --git a/Source/cmMachO.cxx b/Source/cmMachO.cxx
index ac6dce9..bec3ad8 100644
--- a/Source/cmMachO.cxx
+++ b/Source/cmMachO.cxx
@@ -4,10 +4,13 @@
#include "cmAlgorithms.h"
#include "cmsys/FStream.hxx"
+
#include <cstddef>
#include <string>
#include <vector>
+#include "cm_memory.hxx"
+
// Include the Mach-O format information system header.
#include <mach-o/fat.h>
#include <mach-o/loader.h>
diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx
index 2001c1f..dcee47e 100644
--- a/Source/cmMakefileExecutableTargetGenerator.cxx
+++ b/Source/cmMakefileExecutableTargetGenerator.cxx
@@ -2,13 +2,14 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmMakefileExecutableTargetGenerator.h"
-#include <memory>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmGeneratedFileStream.h"
#include "cmGeneratorTarget.h"
diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx
index e5aed01..bdde4b8 100644
--- a/Source/cmMakefileLibraryTargetGenerator.cxx
+++ b/Source/cmMakefileLibraryTargetGenerator.cxx
@@ -2,13 +2,14 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmMakefileLibraryTargetGenerator.h"
-#include <memory>
#include <set>
#include <sstream>
#include <stddef.h>
#include <utility>
#include <vector>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmGeneratedFileStream.h"
#include "cmGeneratorTarget.h"
diff --git a/Source/cmMakefileUtilityTargetGenerator.cxx b/Source/cmMakefileUtilityTargetGenerator.cxx
index 70d9fca..8ed6be5 100644
--- a/Source/cmMakefileUtilityTargetGenerator.cxx
+++ b/Source/cmMakefileUtilityTargetGenerator.cxx
@@ -2,13 +2,13 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmMakefileUtilityTargetGenerator.h"
-#include <memory>
#include <ostream>
#include <string>
#include <utility>
#include <vector>
-#include "cmAlgorithms.h"
+#include "cm_memory.hxx"
+
#include "cmGeneratedFileStream.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalUnixMakefileGenerator3.h"
diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx
index d1af9e6..88040f8 100644
--- a/Source/cmNinjaNormalTargetGenerator.cxx
+++ b/Source/cmNinjaNormalTargetGenerator.cxx
@@ -6,11 +6,12 @@
#include <assert.h>
#include <iterator>
#include <map>
-#include <memory>
#include <set>
#include <sstream>
#include <utility>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmCustomCommand.h" // IWYU pragma: keep
#include "cmCustomCommandGenerator.h"
diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx
index 57e500e..de79817 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -8,10 +8,11 @@
#include <assert.h>
#include <iterator>
#include <map>
-#include <memory>
#include <ostream>
#include <utility>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmComputeLinkInformation.h"
#include "cmCustomCommandGenerator.h"
diff --git a/Source/cmQtAutoGenGlobalInitializer.cxx b/Source/cmQtAutoGenGlobalInitializer.cxx
index ef8a56b..f172b77 100644
--- a/Source/cmQtAutoGenGlobalInitializer.cxx
+++ b/Source/cmQtAutoGenGlobalInitializer.cxx
@@ -4,7 +4,6 @@
#include "cmQtAutoGen.h"
#include "cmQtAutoGenInitializer.h"
-#include "cmAlgorithms.h"
#include "cmCustomCommandLines.h"
#include "cmDuration.h"
#include "cmGeneratorTarget.h"
@@ -17,9 +16,10 @@
#include "cmSystemTools.h"
#include "cmTarget.h"
-#include <memory>
#include <utility>
+#include "cm_memory.hxx"
+
cmQtAutoGenGlobalInitializer::Keywords::Keywords()
: AUTOMOC("AUTOMOC")
, AUTOUIC("AUTOUIC")
diff --git a/Source/cmQtAutoGenInitializer.cxx b/Source/cmQtAutoGenInitializer.cxx
index 83a1bc4..4b12419 100644
--- a/Source/cmQtAutoGenInitializer.cxx
+++ b/Source/cmQtAutoGenInitializer.cxx
@@ -38,6 +38,8 @@
#include <utility>
#include <vector>
+#include "cm_memory.hxx"
+
static std::size_t GetParallelCPUCount()
{
static std::size_t count = 0;
diff --git a/Source/cmQtAutoGenerator.cxx b/Source/cmQtAutoGenerator.cxx
index 3a3162d..2516d84 100644
--- a/Source/cmQtAutoGenerator.cxx
+++ b/Source/cmQtAutoGenerator.cxx
@@ -5,7 +5,8 @@
#include "cmsys/FStream.hxx"
-#include "cmAlgorithms.h"
+#include "cm_memory.hxx"
+
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmState.h"
@@ -14,8 +15,6 @@
#include "cmSystemTools.h"
#include "cmake.h"
-#include <memory>
-
cmQtAutoGenerator::Logger::Logger()
{
// Initialize logger
diff --git a/Source/cmQtAutoMocUic.cxx b/Source/cmQtAutoMocUic.cxx
index 889f47d..44d2db0 100644
--- a/Source/cmQtAutoMocUic.cxx
+++ b/Source/cmQtAutoMocUic.cxx
@@ -5,11 +5,12 @@
#include <algorithm>
#include <array>
#include <list>
-#include <memory>
#include <set>
#include <sstream>
#include <utility>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmCryptoHash.h"
#include "cmGeneratedFileStream.h"
diff --git a/Source/cmRuntimeDependencyArchive.cxx b/Source/cmRuntimeDependencyArchive.cxx
index a1d1f95..45aff69 100644
--- a/Source/cmRuntimeDependencyArchive.cxx
+++ b/Source/cmRuntimeDependencyArchive.cxx
@@ -3,7 +3,6 @@
#include "cmRuntimeDependencyArchive.h"
-#include "cmAlgorithms.h"
#include "cmBinUtilsLinuxELFLinker.h"
#include "cmBinUtilsMacOSMachOLinker.h"
#include "cmBinUtilsWindowsPELinker.h"
@@ -27,6 +26,8 @@
#include <utility>
#include <vector>
+#include "cm_memory.hxx"
+
#if defined(_WIN32)
static void AddVisualStudioPath(std::vector<std::string>& paths,
const std::string& prefix,
diff --git a/Source/cmServer.cxx b/Source/cmServer.cxx
index 1903fd9..9df1883 100644
--- a/Source/cmServer.cxx
+++ b/Source/cmServer.cxx
@@ -2,7 +2,6 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmServer.h"
-#include "cmAlgorithms.h"
#include "cmConnection.h"
#include "cmFileMonitor.h"
#include "cmJsonObjectDictionary.h"
@@ -18,10 +17,11 @@
#include <cassert>
#include <cstdint>
#include <iostream>
-#include <memory>
#include <mutex>
#include <utility>
+#include "cm_memory.hxx"
+
void on_signal(uv_signal_t* signal, int signum)
{
auto conn = static_cast<cmServerBase*>(signal->data);
diff --git a/Source/cmServerProtocol.cxx b/Source/cmServerProtocol.cxx
index 558391f..c5de742 100644
--- a/Source/cmServerProtocol.cxx
+++ b/Source/cmServerProtocol.cxx
@@ -2,7 +2,6 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmServerProtocol.h"
-#include "cmAlgorithms.h"
#include "cmExternalMakefileProjectGenerator.h"
#include "cmFileMonitor.h"
#include "cmGlobalGenerator.h"
@@ -19,11 +18,12 @@
#include <algorithm>
#include <cassert>
#include <functional>
-#include <memory>
#include <string>
#include <utility>
#include <vector>
+#include "cm_memory.hxx"
+
// Get rid of some windows macros:
#undef max
diff --git a/Source/cmState.cxx b/Source/cmState.cxx
index 587cda5..878d5b6 100644
--- a/Source/cmState.cxx
+++ b/Source/cmState.cxx
@@ -8,6 +8,8 @@
#include <string.h>
#include <utility>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmCacheManager.h"
#include "cmCommand.h"
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index b10b30f..28d8c64 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -12,6 +12,8 @@
#include <string.h>
#include <unordered_set>
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmCustomCommand.h"
#include "cmGeneratorExpression.h"
diff --git a/Source/cmUVProcessChain.cxx b/Source/cmUVProcessChain.cxx
index 90ece0b..fbd5634 100644
--- a/Source/cmUVProcessChain.cxx
+++ b/Source/cmUVProcessChain.cxx
@@ -11,9 +11,10 @@
#include <assert.h>
#include <iterator>
-#include <memory>
#include <utility>
+#include "cm_memory.hxx"
+
struct cmUVProcessChain::InternalData
{
struct BasicStreamData
diff --git a/Source/cmVisualStudio10TargetGenerator.cxx b/Source/cmVisualStudio10TargetGenerator.cxx
index e2a4816..ae347fe 100644
--- a/Source/cmVisualStudio10TargetGenerator.cxx
+++ b/Source/cmVisualStudio10TargetGenerator.cxx
@@ -19,9 +19,10 @@
#include "windows.h"
#include <iterator>
-#include <memory>
#include <set>
+#include "cm_memory.hxx"
+
static void ConvertToWindowsSlash(std::string& s);
static std::string cmVS10EscapeXML(std::string arg)
diff --git a/Source/cmWorkerPool.cxx b/Source/cmWorkerPool.cxx
index cbf070e..974100b 100644
--- a/Source/cmWorkerPool.cxx
+++ b/Source/cmWorkerPool.cxx
@@ -16,6 +16,8 @@
#include <stddef.h>
#include <thread>
+#include "cm_memory.hxx"
+
/**
* @brief libuv pipe buffer class
*/
diff --git a/Source/cmWorkerPool.h b/Source/cmWorkerPool.h
index 5cc308b..d708118 100644
--- a/Source/cmWorkerPool.h
+++ b/Source/cmWorkerPool.h
@@ -5,14 +5,13 @@
#include "cmConfigure.h" // IWYU pragma: keep
-#include "cmAlgorithms.h" // IWYU pragma: keep
-
-#include <memory>
#include <stdint.h>
#include <string>
#include <utility>
#include <vector>
+#include "cm_memory.hxx"
+
// -- Types
class cmWorkerPoolInternal;
diff --git a/Source/cm_memory.hxx b/Source/cm_memory.hxx
new file mode 100644
index 0000000..9f5e678
--- /dev/null
+++ b/Source/cm_memory.hxx
@@ -0,0 +1,31 @@
+/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+ file Copyright.txt or https://cmake.org/licensing for details. */
+#ifndef cm_memory_hxx
+#define cm_memory_hxx
+
+#include "cmConfigure.h" // IWYU pragma: keep
+
+#include <memory> // IWYU pragma: export
+#if !defined(CMake_HAVE_CXX_MAKE_UNIQUE)
+# include <utility>
+#endif
+
+namespace cm {
+
+#if defined(CMake_HAVE_CXX_MAKE_UNIQUE)
+
+using std::make_unique;
+
+#else
+
+template <typename T, typename... Args>
+std::unique_ptr<T> make_unique(Args&&... args)
+{
+ return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+
+#endif
+
+} // namespace cm
+
+#endif
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index b8238a2..7250e51 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -2,6 +2,8 @@
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmake.h"
+#include "cm_memory.hxx"
+
#include "cmAlgorithms.h"
#include "cmCommands.h"
#include "cmDocumentation.h"
@@ -104,7 +106,6 @@
#include <cstring>
#include <initializer_list>
#include <iostream>
-#include <memory>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
diff --git a/Tests/CMakeLib/testUVProcessChain.cxx b/Tests/CMakeLib/testUVProcessChain.cxx
index e926350..2c1202e 100644
--- a/Tests/CMakeLib/testUVProcessChain.cxx
+++ b/Tests/CMakeLib/testUVProcessChain.cxx
@@ -1,6 +1,5 @@
#include "cmUVProcessChain.h"
-#include "cmAlgorithms.h"
#include "cmGetPipes.h"
#include "cmUVHandlePtr.h"
#include "cmUVStreambuf.h"
@@ -17,6 +16,8 @@
#include <csignal>
+#include "cm_memory.hxx"
+
struct ExpectedStatus
{
bool Finished;
diff --git a/Utilities/IWYU/mapping.imp b/Utilities/IWYU/mapping.imp
index 4e00214..9fff442 100644
--- a/Utilities/IWYU/mapping.imp
+++ b/Utilities/IWYU/mapping.imp
@@ -51,7 +51,9 @@
{ symbol: [ "std::allocator_traits<std::allocator<cmOrderDirectories::ConflictList> >::value_type", private, "<vector>", public ] },
{ symbol: [ "std::allocator_traits<std::allocator<cmStateSnapshot> >::value_type", private, "<vector>", public ] },
{ symbol: [ "std::allocator_traits<std::allocator<std::basic_string<char> > >::value_type", private, "<vector>", public ] },
+ { symbol: [ "std::allocator_traits<std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > >::value_type", private, "<vector>", public ] },
{ symbol: [ "std::allocator_traits<std::allocator<std::vector<std::basic_string<char>, std::allocator<std::basic_string<char> > > > >::value_type", private, "<vector>", public ] },
+ { symbol: [ "std::allocator_traits<std::allocator<std::vector<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > >::value_type", private, "<vector>", public ] },
{ symbol: [ "std::allocator_traits<std::allocator<uv_stdio_container_s> >::value_type", private, "<vector>", public ] },
# TODO: enable this block and remove some <utility> includes?
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=7ff9ab3b101b131bd4a91a459f66ce27f97f4757
commit 7ff9ab3b101b131bd4a91a459f66ce27f97f4757
Author: Brad King <brad.king at kitware.com>
AuthorDate: Fri Jul 12 12:37:28 2019 -0400
Commit: Brad King <brad.king at kitware.com>
CommitDate: Fri Jul 12 17:37:02 2019 -0400
Makefile: De-duplicate executable link rule lookup
Use `GetCreateRuleVariable` instead of duplicating the variable lookup.
diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx
index 2001c1f..2950bfb 100644
--- a/Source/cmMakefileExecutableTargetGenerator.cxx
+++ b/Source/cmMakefileExecutableTargetGenerator.cxx
@@ -482,9 +482,8 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
// Construct the main link rule.
std::vector<std::string> real_link_commands;
- std::string linkRuleVar = "CMAKE_";
- linkRuleVar += linkLanguage;
- linkRuleVar += "_LINK_EXECUTABLE";
+ std::string linkRuleVar = this->GeneratorTarget->GetCreateRuleVariable(
+ linkLanguage, this->ConfigName);
std::string linkRule = this->GetLinkRule(linkRuleVar);
std::vector<std::string> commands1;
cmSystemTools::ExpandListArgument(linkRule, real_link_commands);
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=79f5ef19fe418efe2d9bfc55fcd16dfd75f18d49
commit 79f5ef19fe418efe2d9bfc55fcd16dfd75f18d49
Author: Brad King <brad.king at kitware.com>
AuthorDate: Fri Jul 12 13:36:15 2019 -0400
Commit: Brad King <brad.king at kitware.com>
CommitDate: Fri Jul 12 17:35:49 2019 -0400
De-duplicate checks for whether a platform uses Windows DLLs
diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx
index 54f6e80..c807f6d 100644
--- a/Source/cmGeneratorTarget.cxx
+++ b/Source/cmGeneratorTarget.cxx
@@ -259,9 +259,6 @@ cmGeneratorTarget::cmGeneratorTarget(cmTarget* t, cmLocalGenerator* lg)
t->GetSourceBacktraces(),
this->SourceEntries, true);
- this->DLLPlatform =
- !this->Makefile->GetSafeDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX").empty();
-
this->PolicyMap = t->GetPolicyMap();
}
@@ -2357,7 +2354,7 @@ void cmGeneratorTarget::ComputeModuleDefinitionInfo(
bool cmGeneratorTarget::IsDLLPlatform() const
{
- return this->DLLPlatform;
+ return this->Target->IsDLLPlatform();
}
void cmGeneratorTarget::GetAutoUicOptions(std::vector<std::string>& result,
diff --git a/Source/cmGeneratorTarget.h b/Source/cmGeneratorTarget.h
index 852f8fd..e86535d 100644
--- a/Source/cmGeneratorTarget.h
+++ b/Source/cmGeneratorTarget.h
@@ -913,7 +913,6 @@ private:
mutable bool DebugSourcesDone;
mutable bool LinkImplementationLanguageIsContextDependent;
mutable bool UtilityItemsDone;
- bool DLLPlatform;
bool ComputePDBOutputDir(const std::string& kind, const std::string& config,
std::string& out) const;
diff --git a/Source/cmInstallCommand.cxx b/Source/cmInstallCommand.cxx
index dba4bbb..750ed8c 100644
--- a/Source/cmInstallCommand.cxx
+++ b/Source/cmInstallCommand.cxx
@@ -389,10 +389,6 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
return true;
}
- // Check whether this is a DLL platform.
- bool dll_platform =
- !this->Makefile->GetSafeDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX").empty();
-
for (std::string const& tgt : targetList) {
if (this->Makefile->IsAlias(tgt)) {
@@ -472,7 +468,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
// Shared libraries are handled differently on DLL and non-DLL
// platforms. All windows platforms are DLL platforms including
// cygwin. Currently no other platform is a DLL platform.
- if (dll_platform) {
+ if (target.IsDLLPlatform()) {
// When in namelink only mode skip all libraries on Windows.
if (namelinkMode == cmInstallTargetGenerator::NamelinkModeOnly) {
continue;
@@ -641,7 +637,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
// On DLL platforms an executable may also have an import
// library. Install it to the archive destination if it
// exists.
- if (dll_platform && !archiveArgs.GetDestination().empty() &&
+ if (target.IsDLLPlatform() && !archiveArgs.GetDestination().empty() &&
target.IsExecutableWithExports()) {
// The import library uses the ARCHIVE properties.
archiveGenerator = CreateInstallTargetGenerator(
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index b10b30f..2237d9b 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -168,7 +168,7 @@ public:
cmPropertyMap Properties;
bool IsGeneratorProvided;
bool HaveInstallRule;
- bool DLLPlatform;
+ bool IsDLLPlatform;
bool IsAndroid;
bool IsImportedTarget;
bool ImportedGloballyVisible;
@@ -216,7 +216,7 @@ cmTarget::cmTarget(std::string const& name, cmStateEnums::TargetType type,
impl->Name = name;
impl->IsGeneratorProvided = false;
impl->HaveInstallRule = false;
- impl->DLLPlatform = false;
+ impl->IsDLLPlatform = false;
impl->IsAndroid = false;
impl->IsImportedTarget =
(vis == VisibilityImported || vis == VisibilityImportedGlobally);
@@ -224,7 +224,7 @@ cmTarget::cmTarget(std::string const& name, cmStateEnums::TargetType type,
impl->BuildInterfaceIncludesAppended = false;
// Check whether this is a DLL platform.
- impl->DLLPlatform =
+ impl->IsDLLPlatform =
!impl->Makefile->GetSafeDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX").empty();
// Check whether we are targeting an Android platform.
@@ -1657,6 +1657,11 @@ cmPropertyMap const& cmTarget::GetProperties() const
return impl->Properties;
}
+bool cmTarget::IsDLLPlatform() const
+{
+ return impl->IsDLLPlatform;
+}
+
bool cmTarget::IsImported() const
{
return impl->IsImportedTarget;
@@ -1872,7 +1877,7 @@ bool cmTarget::GetMappedConfig(std::string const& desired_config,
// If we needed to find one of the mapped configurations but did not
// On a DLL platform there may be only IMPORTED_IMPLIB for a shared
// library or an executable with exports.
- bool allowImp = (impl->DLLPlatform &&
+ bool allowImp = (this->IsDLLPlatform() &&
(this->GetType() == cmStateEnums::SHARED_LIBRARY ||
this->IsExecutableWithExports()));
diff --git a/Source/cmTarget.h b/Source/cmTarget.h
index f47cc14..d9e87b8 100644
--- a/Source/cmTarget.h
+++ b/Source/cmTarget.h
@@ -177,6 +177,9 @@ public:
//! Get all properties
cmPropertyMap const& GetProperties() const;
+ //! Return whether or not the target is for a DLL platform.
+ bool IsDLLPlatform() const;
+
bool IsImported() const;
bool IsImportedGloballyVisible() const;
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=22d3eb5d5e4ce9c6371ab709655928552453fbda
commit 22d3eb5d5e4ce9c6371ab709655928552453fbda
Author: Brad King <brad.king at kitware.com>
AuthorDate: Fri Jul 12 11:22:36 2019 -0400
Commit: Brad King <brad.king at kitware.com>
CommitDate: Fri Jul 12 17:29:40 2019 -0400
Refactor checks for whether a target has an import library
Use `HasImportLibrary` for such checks.
diff --git a/Source/cmComputeLinkInformation.cxx b/Source/cmComputeLinkInformation.cxx
index b366ebb..5a03670 100644
--- a/Source/cmComputeLinkInformation.cxx
+++ b/Source/cmComputeLinkInformation.cxx
@@ -268,10 +268,6 @@ cmComputeLinkInformation::cmComputeLinkInformation(
return;
}
- // Check whether we should use an import library for linking a target.
- this->UseImportLibrary =
- this->Makefile->IsDefinitionSet("CMAKE_IMPORT_LIBRARY_SUFFIX");
-
// Check whether we should skip dependencies on shared library files.
this->LinkDependsNoShared =
this->Target->GetPropertyAsBool("LINK_DEPENDS_NO_SHARED");
@@ -280,7 +276,7 @@ cmComputeLinkInformation::cmComputeLinkInformation(
// to use when creating a plugin (module) that obtains symbols from
// the program that will load it.
this->LoaderFlag = nullptr;
- if (!this->UseImportLibrary &&
+ if (!this->Target->IsDLLPlatform() &&
this->Target->GetType() == cmStateEnums::MODULE_LIBRARY) {
std::string loader_flag_var = "CMAKE_SHARED_MODULE_LOADER_";
loader_flag_var += this->LinkLanguage;
@@ -493,9 +489,7 @@ bool cmComputeLinkInformation::Compute()
std::set<cmGeneratorTarget const*> const& wrongItems =
cld.GetOldWrongConfigItems();
for (cmGeneratorTarget const* tgt : wrongItems) {
- bool implib = (this->UseImportLibrary &&
- (tgt->GetType() == cmStateEnums::SHARED_LIBRARY));
- cmStateEnums::ArtifactType artifact = implib
+ cmStateEnums::ArtifactType artifact = tgt->HasImportLibrary(this->Config)
? cmStateEnums::ImportLibraryArtifact
: cmStateEnums::RuntimeBinaryArtifact;
this->OldLinkDirItems.push_back(
@@ -578,7 +572,7 @@ void cmComputeLinkInformation::AddItem(std::string const& item,
// Compute the proper name to use to link this library.
const std::string& config = this->Config;
bool impexe = (tgt && tgt->IsExecutableWithExports());
- if (impexe && !this->UseImportLibrary && !this->LoaderFlag) {
+ if (impexe && !tgt->HasImportLibrary(config) && !this->LoaderFlag) {
// Skip linking to executables on platforms with no import
// libraries or loader flags.
return;
@@ -592,7 +586,7 @@ void cmComputeLinkInformation::AddItem(std::string const& item,
// platform. Add it now.
std::string linkItem;
linkItem = this->LoaderFlag;
- cmStateEnums::ArtifactType artifact = this->UseImportLibrary
+ cmStateEnums::ArtifactType artifact = tgt->HasImportLibrary(config)
? cmStateEnums::ImportLibraryArtifact
: cmStateEnums::RuntimeBinaryArtifact;
@@ -616,10 +610,7 @@ void cmComputeLinkInformation::AddItem(std::string const& item,
// Its object-files should already have been extracted for linking.
} else {
// Decide whether to use an import library.
- bool implib =
- (this->UseImportLibrary &&
- (impexe || tgt->GetType() == cmStateEnums::SHARED_LIBRARY));
- cmStateEnums::ArtifactType artifact = implib
+ cmStateEnums::ArtifactType artifact = tgt->HasImportLibrary(config)
? cmStateEnums::ImportLibraryArtifact
: cmStateEnums::RuntimeBinaryArtifact;
@@ -694,7 +685,7 @@ void cmComputeLinkInformation::AddSharedDepItem(std::string const& item,
// linked will be able to find it.
std::string lib;
if (tgt) {
- cmStateEnums::ArtifactType artifact = this->UseImportLibrary
+ cmStateEnums::ArtifactType artifact = tgt->HasImportLibrary(this->Config)
? cmStateEnums::ImportLibraryArtifact
: cmStateEnums::RuntimeBinaryArtifact;
lib = tgt->GetFullPath(this->Config, artifact);
diff --git a/Source/cmComputeLinkInformation.h b/Source/cmComputeLinkInformation.h
index 863639c..3be2c7f 100644
--- a/Source/cmComputeLinkInformation.h
+++ b/Source/cmComputeLinkInformation.h
@@ -179,7 +179,6 @@ private:
bool OldLinkDirMode;
bool OpenBSD;
bool LinkDependsNoShared;
- bool UseImportLibrary;
bool RuntimeUseChrpath;
bool NoSONameUsesPath;
bool LinkWithRuntimePath;
diff --git a/Source/cmExportBuildFileGenerator.cxx b/Source/cmExportBuildFileGenerator.cxx
index 5800629..de3e0e2 100644
--- a/Source/cmExportBuildFileGenerator.cxx
+++ b/Source/cmExportBuildFileGenerator.cxx
@@ -236,14 +236,15 @@ void cmExportBuildFileGenerator::SetImportLocationProperty(
}
// Add the import library for windows DLLs.
- if (target->HasImportLibrary(config) &&
- mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")) {
+ if (target->HasImportLibrary(config)) {
std::string prop = "IMPORTED_IMPLIB";
prop += suffix;
std::string value =
target->GetFullPath(config, cmStateEnums::ImportLibraryArtifact);
- target->GetImplibGNUtoMS(config, value, value,
- "${CMAKE_IMPORT_LIBRARY_SUFFIX}");
+ if (mf->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")) {
+ target->GetImplibGNUtoMS(config, value, value,
+ "${CMAKE_IMPORT_LIBRARY_SUFFIX}");
+ }
properties[prop] = value;
}
}
diff --git a/Source/cmFileAPICodemodel.cxx b/Source/cmFileAPICodemodel.cxx
index 73b4123..7b916cd 100644
--- a/Source/cmFileAPICodemodel.cxx
+++ b/Source/cmFileAPICodemodel.cxx
@@ -1076,17 +1076,16 @@ Json::Value Target::DumpArtifacts()
}
// Add Windows-specific artifacts produced by the linker.
+ if (this->GT->HasImportLibrary(this->Config)) {
+ Json::Value artifact = Json::objectValue;
+ artifact["path"] =
+ RelativeIfUnder(this->TopBuild,
+ this->GT->GetFullPath(
+ this->Config, cmStateEnums::ImportLibraryArtifact));
+ artifacts.append(std::move(artifact)); // NOLINT(*)
+ }
if (this->GT->IsDLLPlatform() &&
this->GT->GetType() != cmStateEnums::STATIC_LIBRARY) {
- if (this->GT->GetType() == cmStateEnums::SHARED_LIBRARY ||
- this->GT->IsExecutableWithExports()) {
- Json::Value artifact = Json::objectValue;
- artifact["path"] =
- RelativeIfUnder(this->TopBuild,
- this->GT->GetFullPath(
- this->Config, cmStateEnums::ImportLibraryArtifact));
- artifacts.append(std::move(artifact)); // NOLINT(*)
- }
cmGeneratorTarget::OutputInfo const* output =
this->GT->GetOutputInfo(this->Config);
if (output && !output->PdbDir.empty()) {
diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx
index 845937a..54f6e80 100644
--- a/Source/cmGeneratorTarget.cxx
+++ b/Source/cmGeneratorTarget.cxx
@@ -468,7 +468,7 @@ std::string cmGeneratorTarget::GetFilePrefix(
const std::string& config, cmStateEnums::ArtifactType artifact) const
{
if (this->IsImported()) {
- const char* prefix = this->GetFilePrefixInternal(artifact);
+ const char* prefix = this->GetFilePrefixInternal(config, artifact);
return prefix ? prefix : std::string();
}
@@ -481,7 +481,7 @@ std::string cmGeneratorTarget::GetFileSuffix(
const std::string& config, cmStateEnums::ArtifactType artifact) const
{
if (this->IsImported()) {
- const char* suffix = this->GetFileSuffixInternal(artifact);
+ const char* suffix = this->GetFileSuffixInternal(config, artifact);
return suffix ? suffix : std::string();
}
@@ -508,7 +508,8 @@ std::string cmGeneratorTarget::GetFilePostfix(const std::string& config) const
}
const char* cmGeneratorTarget::GetFilePrefixInternal(
- cmStateEnums::ArtifactType artifact, const std::string& language) const
+ std::string const& config, cmStateEnums::ArtifactType artifact,
+ const std::string& language) const
{
// no prefix for non-main target types.
if (this->GetType() != cmStateEnums::STATIC_LIBRARY &&
@@ -523,8 +524,7 @@ const char* cmGeneratorTarget::GetFilePrefixInternal(
// Return an empty prefix for the import library if this platform
// does not support import libraries.
- if (isImportedLibraryArtifact &&
- !this->Makefile->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")) {
+ if (isImportedLibraryArtifact && !this->NeedImportLibraryName(config)) {
return nullptr;
}
@@ -558,7 +558,8 @@ const char* cmGeneratorTarget::GetFilePrefixInternal(
return targetPrefix;
}
const char* cmGeneratorTarget::GetFileSuffixInternal(
- cmStateEnums::ArtifactType artifact, const std::string& language) const
+ std::string const& config, cmStateEnums::ArtifactType artifact,
+ const std::string& language) const
{
// no suffix for non-main target types.
if (this->GetType() != cmStateEnums::STATIC_LIBRARY &&
@@ -573,8 +574,7 @@ const char* cmGeneratorTarget::GetFileSuffixInternal(
// Return an empty suffix for the import library if this platform
// does not support import libraries.
- if (isImportedLibraryArtifact &&
- !this->Makefile->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")) {
+ if (isImportedLibraryArtifact && !this->NeedImportLibraryName(config)) {
return nullptr;
}
@@ -3924,8 +3924,7 @@ void cmGeneratorTarget::GetFullNameInternal(
// Return an empty name for the import library if this platform
// does not support import libraries.
- if (isImportedLibraryArtifact &&
- !this->Makefile->GetDefinition("CMAKE_IMPORT_LIBRARY_SUFFIX")) {
+ if (isImportedLibraryArtifact && !this->NeedImportLibraryName(config)) {
outPrefix.clear();
outBase.clear();
outSuffix.clear();
@@ -3934,8 +3933,8 @@ void cmGeneratorTarget::GetFullNameInternal(
// retrieve prefix and suffix
std::string ll = this->GetLinkerLanguage(config);
- const char* targetPrefix = this->GetFilePrefixInternal(artifact, ll);
- const char* targetSuffix = this->GetFileSuffixInternal(artifact, ll);
+ const char* targetPrefix = this->GetFilePrefixInternal(config, artifact, ll);
+ const char* targetSuffix = this->GetFileSuffixInternal(config, artifact, ll);
// The implib option is only allowed for shared libraries, module
// libraries, and executables.
@@ -6363,6 +6362,16 @@ bool cmGeneratorTarget::HasImportLibrary(std::string const& config) const
this->GetManagedType(config) != ManagedType::Managed);
}
+bool cmGeneratorTarget::NeedImportLibraryName(std::string const& config) const
+{
+ return this->HasImportLibrary(config) ||
+ // On DLL platforms we always generate the import library name
+ // just in case the sources have export markup.
+ (this->IsDLLPlatform() &&
+ (this->GetType() == cmStateEnums::EXECUTABLE ||
+ this->GetType() == cmStateEnums::MODULE_LIBRARY));
+}
+
std::string cmGeneratorTarget::GetSupportDirectory() const
{
std::string dir = this->LocalGenerator->GetCurrentBinaryDirectory();
diff --git a/Source/cmGeneratorTarget.h b/Source/cmGeneratorTarget.h
index 627a055..852f8fd 100644
--- a/Source/cmGeneratorTarget.h
+++ b/Source/cmGeneratorTarget.h
@@ -743,9 +743,13 @@ private:
mutable std::map<std::string, bool> DebugCompatiblePropertiesDone;
- const char* GetFilePrefixInternal(cmStateEnums::ArtifactType artifact,
+ bool NeedImportLibraryName(std::string const& config) const;
+
+ const char* GetFilePrefixInternal(std::string const& config,
+ cmStateEnums::ArtifactType artifact,
const std::string& language = "") const;
- const char* GetFileSuffixInternal(cmStateEnums::ArtifactType artifact,
+ const char* GetFileSuffixInternal(std::string const& config,
+ cmStateEnums::ArtifactType artifact,
const std::string& language = "") const;
std::string GetFullNameInternal(const std::string& config,
diff --git a/Source/cmJsonObjects.cxx b/Source/cmJsonObjects.cxx
index 505188f..2423faf 100644
--- a/Source/cmJsonObjects.cxx
+++ b/Source/cmJsonObjects.cxx
@@ -516,9 +516,11 @@ static Json::Value DumpTarget(cmGeneratorTarget* target,
Json::Value artifacts = Json::arrayValue;
artifacts.append(
target->GetFullPath(config, cmStateEnums::RuntimeBinaryArtifact));
- if (target->IsDLLPlatform()) {
+ if (target->HasImportLibrary(config)) {
artifacts.append(
target->GetFullPath(config, cmStateEnums::ImportLibraryArtifact));
+ }
+ if (target->IsDLLPlatform()) {
const cmGeneratorTarget::OutputInfo* output =
target->GetOutputInfo(config);
if (output && !output->PdbDir.empty()) {
diff --git a/Source/cmLinkLineComputer.cxx b/Source/cmLinkLineComputer.cxx
index 469faca..8746b35 100644
--- a/Source/cmLinkLineComputer.cxx
+++ b/Source/cmLinkLineComputer.cxx
@@ -110,8 +110,7 @@ std::string cmLinkLineComputer::ComputeLinkPath(
if (target->GetType() == cmStateEnums::STATIC_LIBRARY ||
target->GetType() == cmStateEnums::SHARED_LIBRARY) {
cmStateEnums::ArtifactType type = cmStateEnums::RuntimeBinaryArtifact;
- if (target->GetType() == cmStateEnums::SHARED_LIBRARY &&
- target->IsDLLPlatform()) {
+ if (target->HasImportLibrary(cli.GetConfig())) {
type = cmStateEnums::ImportLibraryArtifact;
}
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=3af48083a24676025590e1e3a8db2cfef0317901
commit 3af48083a24676025590e1e3a8db2cfef0317901
Merge: 366746b f84d204
Author: Brad King <brad.king at kitware.com>
AuthorDate: Fri Jul 12 16:21:12 2019 -0400
Commit: Brad King <brad.king at kitware.com>
CommitDate: Fri Jul 12 16:21:12 2019 -0400
Merge branch 'FindBISON-CMP0088-SourcePath' into release-3.14
Merge-request: !3549
-----------------------------------------------------------------------
Summary of changes:
Help/release/3.14.rst | 8 +
Modules/FindBISON.cmake | 12 +-
Source/CPack/cmCPackExternalGenerator.cxx | 3 +-
Source/CTest/cmCTestBuildCommand.h | 11 +-
Source/CTest/cmCTestConfigureCommand.h | 11 +-
Source/CTest/cmCTestCoverageCommand.h | 11 +-
Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h | 12 +-
Source/CTest/cmCTestMemCheckCommand.h | 12 +-
Source/CTest/cmCTestReadCustomFilesCommand.h | 11 +-
Source/CTest/cmCTestRunScriptCommand.h | 11 +-
Source/CTest/cmCTestRunTest.cxx | 3 +-
Source/CTest/cmCTestScriptHandler.cxx | 42 ++--
Source/CTest/cmCTestScriptHandler.h | 4 +-
Source/CTest/cmCTestSleepCommand.h | 11 +-
Source/CTest/cmCTestStartCommand.h | 11 +-
Source/CTest/cmCTestSubmitCommand.cxx | 10 +-
Source/CTest/cmCTestSubmitCommand.h | 5 +-
Source/CTest/cmCTestTestCommand.h | 11 +-
Source/CTest/cmCTestTestHandler.cxx | 58 ++---
Source/CTest/cmCTestUpdateCommand.h | 11 +-
Source/CTest/cmCTestUpdateHandler.cxx | 4 +-
Source/CTest/cmCTestUploadCommand.h | 11 +-
Source/cmAddCompileDefinitionsCommand.h | 7 +-
Source/cmAddCompileOptionsCommand.h | 7 +-
Source/cmAddCustomCommandCommand.h | 7 +-
Source/cmAddCustomTargetCommand.h | 7 +-
Source/cmAddDefinitionsCommand.h | 7 +-
Source/cmAddDependenciesCommand.h | 7 +-
Source/cmAddExecutableCommand.h | 7 +-
Source/cmAddLibraryCommand.h | 7 +-
Source/cmAddLinkOptionsCommand.h | 7 +-
Source/cmAddSubDirectoryCommand.h | 7 +-
Source/cmAddTestCommand.h | 7 +-
Source/cmAlgorithms.h | 15 --
Source/cmAuxSourceDirectoryCommand.h | 7 +-
Source/cmBinUtilsLinuxELFLinker.cxx | 5 +-
Source/cmBinUtilsMacOSMachOLinker.cxx | 2 +
Source/cmBinUtilsWindowsPELinker.cxx | 5 +-
Source/cmBreakCommand.h | 7 +-
Source/cmBuildCommand.h | 7 +-
Source/cmBuildNameCommand.h | 7 +-
Source/cmCMakeHostSystemInformationCommand.h | 6 +-
Source/cmCMakeMinimumRequired.h | 7 +-
Source/cmCMakePolicyCommand.h | 7 +-
Source/cmCTest.cxx | 3 +-
Source/cmCommand.h | 3 +-
Source/cmCommands.cxx | 269 +++++++++++++---------
Source/cmComputeLinkDepends.cxx | 2 +
Source/cmComputeLinkInformation.cxx | 21 +-
Source/cmComputeLinkInformation.h | 1 -
Source/cmConfigureFileCommand.h | 7 +-
Source/cmContinueCommand.h | 7 +-
Source/cmCreateTestSourceList.h | 7 +-
Source/cmCryptoHash.cxx | 4 +-
Source/cmDefinePropertyCommand.h | 7 +-
Source/cmDisallowedCommand.h | 19 +-
Source/cmEnableLanguageCommand.h | 7 +-
Source/cmEnableTestingCommand.h | 7 +-
Source/cmExecProgramCommand.h | 7 +-
Source/cmExecuteProcessCommand.cxx | 1 -
Source/cmExecuteProcessCommand.h | 7 +-
Source/cmExportBuildFileGenerator.cxx | 9 +-
Source/cmExportCommand.h | 7 +-
Source/cmExportFileGenerator.cxx | 3 +-
Source/cmExportLibraryDependenciesCommand.cxx | 4 +-
Source/cmExportLibraryDependenciesCommand.h | 6 +-
Source/cmFLTKWrapUICommand.h | 7 +-
Source/cmFileAPICodemodel.cxx | 17 +-
Source/cmFileCommand.cxx | 3 +-
Source/cmFileCommand.h | 7 +-
Source/cmFileTimes.cxx | 3 +-
Source/cmFindFileCommand.h | 10 +-
Source/cmFindLibraryCommand.h | 9 +-
Source/cmFindPackageCommand.cxx | 3 +-
Source/cmFindPackageCommand.h | 9 +-
Source/cmFindPathCommand.h | 9 +-
Source/cmFindProgramCommand.h | 9 +-
Source/cmForEachCommand.cxx | 4 +-
Source/cmForEachCommand.h | 7 +-
Source/cmFunctionCommand.cxx | 13 +-
Source/cmFunctionCommand.h | 7 +-
Source/cmGeneratorTarget.cxx | 38 +--
Source/cmGeneratorTarget.h | 9 +-
Source/cmGetCMakePropertyCommand.h | 7 +-
Source/cmGetDirectoryPropertyCommand.h | 7 +-
Source/cmGetFilenameComponentCommand.h | 7 +-
Source/cmGetPropertyCommand.h | 7 +-
Source/cmGetSourceFilePropertyCommand.h | 7 +-
Source/cmGetTargetPropertyCommand.h | 7 +-
Source/cmGetTestPropertyCommand.h | 7 +-
Source/cmGlobalNinjaGenerator.cxx | 3 +-
Source/cmGlobalUnixMakefileGenerator3.cxx | 3 +-
Source/cmGlobalXCodeGenerator.cxx | 3 +-
Source/cmIfCommand.cxx | 2 -
Source/cmIfCommand.h | 7 +-
Source/cmIncludeCommand.h | 7 +-
Source/cmIncludeDirectoryCommand.h | 7 +-
Source/cmIncludeExternalMSProjectCommand.h | 7 +-
Source/cmIncludeGuardCommand.h | 7 +-
Source/cmIncludeRegularExpressionCommand.h | 7 +-
Source/cmInstallCommand.cxx | 8 +-
Source/cmInstallCommand.h | 7 +-
Source/cmInstallFilesCommand.h | 7 +-
Source/cmInstallProgramsCommand.h | 7 +-
Source/cmInstallTargetsCommand.h | 7 +-
Source/cmJsonObjects.cxx | 4 +-
Source/cmLinkDirectoriesCommand.h | 7 +-
Source/cmLinkLibrariesCommand.h | 7 +-
Source/cmLinkLineComputer.cxx | 3 +-
Source/cmListCommand.cxx | 3 +-
Source/cmListCommand.h | 7 +-
Source/cmLoadCacheCommand.h | 7 +-
Source/cmLoadCommandCommand.cxx | 14 +-
Source/cmLoadCommandCommand.h | 7 +-
Source/cmLocalUnixMakefileGenerator3.cxx | 3 +-
Source/cmMachO.cxx | 3 +
Source/cmMacroCommand.cxx | 12 +-
Source/cmMacroCommand.h | 7 +-
Source/cmMakeDirectoryCommand.h | 7 +-
Source/cmMakefile.cxx | 7 +-
Source/cmMakefile.h | 2 +-
Source/cmMakefileExecutableTargetGenerator.cxx | 8 +-
Source/cmMakefileLibraryTargetGenerator.cxx | 3 +-
Source/cmMakefileUtilityTargetGenerator.cxx | 4 +-
Source/cmMarkAsAdvancedCommand.h | 7 +-
Source/cmMathCommand.h | 7 +-
Source/cmMessageCommand.h | 7 +-
Source/cmNinjaNormalTargetGenerator.cxx | 3 +-
Source/cmNinjaTargetGenerator.cxx | 3 +-
Source/cmOptionCommand.h | 7 +-
Source/cmOutputRequiredFilesCommand.h | 7 +-
Source/cmParseArgumentsCommand.h | 7 +-
Source/cmProjectCommand.h | 7 +-
Source/cmQTWrapCPPCommand.h | 7 +-
Source/cmQTWrapUICommand.h | 7 +-
Source/cmQtAutoGenGlobalInitializer.cxx | 4 +-
Source/cmQtAutoGenInitializer.cxx | 2 +
Source/cmQtAutoGenerator.cxx | 5 +-
Source/cmQtAutoMocUic.cxx | 3 +-
Source/cmRemoveCommand.h | 7 +-
Source/cmRemoveDefinitionsCommand.h | 7 +-
Source/cmReturnCommand.h | 7 +-
Source/cmRuntimeDependencyArchive.cxx | 3 +-
Source/cmSeparateArgumentsCommand.h | 7 +-
Source/cmServer.cxx | 4 +-
Source/cmServerProtocol.cxx | 4 +-
Source/cmSetCommand.h | 7 +-
Source/cmSetDirectoryPropertiesCommand.h | 7 +-
Source/cmSetPropertyCommand.h | 7 +-
Source/cmSetSourceFilesPropertiesCommand.h | 7 +-
Source/cmSetTargetPropertiesCommand.h | 7 +-
Source/cmSetTestsPropertiesCommand.h | 7 +-
Source/cmSiteNameCommand.h | 7 +-
Source/cmSourceGroupCommand.h | 7 +-
Source/cmState.cxx | 54 ++---
Source/cmState.h | 13 +-
Source/cmStringCommand.cxx | 1 -
Source/cmStringCommand.h | 7 +-
Source/cmSubdirCommand.h | 7 +-
Source/cmSubdirDependsCommand.h | 7 +-
Source/cmTarget.cxx | 15 +-
Source/cmTarget.h | 3 +
Source/cmTargetCompileDefinitionsCommand.h | 9 +-
Source/cmTargetCompileFeaturesCommand.h | 9 +-
Source/cmTargetCompileOptionsCommand.h | 9 +-
Source/cmTargetIncludeDirectoriesCommand.h | 9 +-
Source/cmTargetLinkDirectoriesCommand.h | 9 +-
Source/cmTargetLinkLibrariesCommand.h | 7 +-
Source/cmTargetLinkOptionsCommand.h | 9 +-
Source/cmTargetSourcesCommand.h | 9 +-
Source/cmTryCompileCommand.h | 9 +-
Source/cmTryRunCommand.h | 9 +-
Source/cmUVProcessChain.cxx | 5 +-
Source/cmUnexpectedCommand.h | 6 +-
Source/cmUnsetCommand.h | 7 +-
Source/cmUseMangledMesaCommand.h | 7 +-
Source/cmUtilitySourceCommand.h | 7 +-
Source/cmVariableRequiresCommand.h | 7 +-
Source/cmVariableWatchCommand.h | 7 +-
Source/cmVisualStudio10TargetGenerator.cxx | 3 +-
Source/cmWhileCommand.cxx | 2 -
Source/cmWhileCommand.h | 7 +-
Source/cmWorkerPool.cxx | 2 +
Source/cmWorkerPool.h | 5 +-
Source/cmWriteFileCommand.h | 7 +-
Source/cm_memory.hxx | 31 +++
Source/cmake.cxx | 3 +-
Tests/CMakeLib/testUVProcessChain.cxx | 4 +-
Utilities/IWYU/mapping.imp | 2 +
189 files changed, 1216 insertions(+), 529 deletions(-)
create mode 100644 Source/cm_memory.hxx
hooks/post-receive
--
CMake
More information about the Cmake-commits
mailing list