kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge topic 'refactor-auto_ptr' 

b5ec5b09 Avoid using KWSys auto_ptr by adopting it ourselves
This commit is contained in:
Brad King 2016-06-30 09:47:38 -04:00 committed by CMake Topic Stage
parent 21afc0291e b5ec5b0901
commit 2bef377427
50 changed files with 381 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Help/manual/cmake-developer.7.rst
View File

@ -24,9 +24,10 @@ to build with such toolchains.
std::auto_ptr
-------------
Some implementations have a ``std::auto_ptr`` which can not be used as a
return value from a function. ``std::auto_ptr`` may not be used. Use
``cmsys::auto_ptr`` instead.
The ``std::auto_ptr`` template is deprecated in C++11. We want to use it
so we can build on C++98 compilers but we do not want to turn off compiler
warnings about deprecated interfaces in general. Use the ``CM_AUTO_PTR``
macro instead.
size_t
------

1
Source/CMakeLists.txt
View File

@ -364,6 +364,7 @@ set(SRCS
cmake.cxx
cmake.h
cm_auto_ptr.hxx
cm_get_date.h
cm_get_date.c
cm_sha2.h

2
Source/CPack/WiX/cmCPackWIXGenerator.cxx
View File

@ -1044,7 +1044,7 @@ std::string cmCPackWIXGenerator::CreateNewIdForPath(std::string const& path)
std::string cmCPackWIXGenerator::CreateHashedId(
std::string const& path, std::string const& normalizedFilename)
{
cmsys::auto_ptr<cmCryptoHash> sha1 = cmCryptoHash::New("SHA1");
CM_AUTO_PTR<cmCryptoHash> sha1 = cmCryptoHash::New("SHA1");
std::string hash = sha1->HashString(path.c_str());
std::string identifier;

2
Source/CPack/cmCPackGenerator.cxx
View File

@ -624,7 +624,7 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
cm.AddCMakePaths();
cm.SetProgressCallback(cmCPackGeneratorProgress, this);
cmGlobalGenerator gg(&cm);
cmsys::auto_ptr<cmMakefile> mf(
CM_AUTO_PTR<cmMakefile> mf(
new cmMakefile(&gg, cm.GetCurrentSnapshot()));
if (!installSubDirectory.empty() && installSubDirectory != "/") {
tempInstallDirectory += installSubDirectory;

2
Source/CPack/cpack.cxx
View File

@ -185,7 +185,7 @@ int main(int argc, char const* const* argv)
cminst.GetCurrentSnapshot().SetDefaultDefinitions();
cminst.GetState()->RemoveUnscriptableCommands();
cmGlobalGenerator cmgg(&cminst);
cmsys::auto_ptr<cmMakefile> globalMF(
CM_AUTO_PTR<cmMakefile> globalMF(
new cmMakefile(&cmgg, cminst.GetCurrentSnapshot()));
#if defined(__CYGWIN__)
globalMF->AddDefinition("CMAKE_LEGACY_CYGWIN_WIN32", "0");

4
Source/CTest/cmCTestLaunch.cxx
View File

@ -612,7 +612,7 @@ int cmCTestLaunch::Main(int argc, const char* const argv[])
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmake.h"
#include <cmsys/auto_ptr.hxx>
#include <cm_auto_ptr.hxx>
void cmCTestLaunch::LoadConfig()
{
cmake cm;
@ -620,7 +620,7 @@ void cmCTestLaunch::LoadConfig()
cm.SetHomeOutputDirectory("");
cm.GetCurrentSnapshot().SetDefaultDefinitions();
cmGlobalGenerator gg(&cm);
cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot()));
CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot()));
std::string fname = this->LogDir;
fname += "CTestLaunchConfig.cmake";
if (cmSystemTools::FileExists(fname.c_str()) &&

2
Source/CTest/cmCTestTestHandler.cxx
View File

@ -1352,7 +1352,7 @@ void cmCTestTestHandler::GetListOfTests()
cm.SetHomeOutputDirectory("");
cm.GetCurrentSnapshot().SetDefaultDefinitions();
cmGlobalGenerator gg(&cm);
cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot()));
CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot()));
mf->AddDefinition("CTEST_CONFIGURATION_TYPE",
this->CTest->GetConfigType().c_str());

4
Source/CTest/cmCTestUpdateHandler.cxx
View File

@ -30,7 +30,7 @@
#include "cmCTestSVN.h"
#include "cmCTestVC.h"
#include <cmsys/auto_ptr.hxx>
#include <cm_auto_ptr.hxx>
//#include <cmsys/RegularExpression.hxx>
#include <cmsys/Process.h>
@ -159,7 +159,7 @@ int cmCTestUpdateHandler::ProcessHandler()
, this->Quiet);
// Create an object to interact with the VCS tool.
cmsys::auto_ptr<cmCTestVC> vc;
CM_AUTO_PTR<cmCTestVC> vc;
switch (this->UpdateType) {
case e_CVS:
vc.reset(new cmCTestCVS(this->CTest, ofs));

8
Source/cmCTest.cxx
View File

@ -51,7 +51,7 @@
#include <math.h>
#include <stdlib.h>
#include <cmsys/auto_ptr.hxx>
#include <cm_auto_ptr.hxx>
#include <cm_zlib.h>
#include <cmsys/Base64.h>
@ -474,7 +474,7 @@ int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command)
cm.SetHomeOutputDirectory("");
cm.GetCurrentSnapshot().SetDefaultDefinitions();
cmGlobalGenerator gg(&cm);
cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot()));
CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot()));
if (!this->ReadCustomConfigurationFileTree(this->BinaryDir.c_str(),
mf.get())) {
cmCTestOptionalLog(
@ -1165,7 +1165,7 @@ int cmCTest::RunTest(std::vector<const char*> argv, std::string* output,
}
std::string oldpath = cmSystemTools::GetCurrentWorkingDirectory();
cmsys::auto_ptr<cmSystemTools::SaveRestoreEnvironment> saveEnv;
CM_AUTO_PTR<cmSystemTools::SaveRestoreEnvironment> saveEnv;
if (modifyEnv) {
saveEnv.reset(new cmSystemTools::SaveRestoreEnvironment);
cmSystemTools::AppendEnv(*environment);
@ -1193,7 +1193,7 @@ int cmCTest::RunTest(std::vector<const char*> argv, std::string* output,
*output = "";
}
cmsys::auto_ptr<cmSystemTools::SaveRestoreEnvironment> saveEnv;
CM_AUTO_PTR<cmSystemTools::SaveRestoreEnvironment> saveEnv;
if (modifyEnv) {
saveEnv.reset(new cmSystemTools::SaveRestoreEnvironment);
cmSystemTools::AppendEnv(*environment);

16
Source/cmCryptoHash.cxx
View File

@ -15,22 +15,22 @@
#include <cmsys/FStream.hxx>
#include <cmsys/MD5.h>
cmsys::auto_ptr<cmCryptoHash> cmCryptoHash::New(const char* algo)
CM_AUTO_PTR<cmCryptoHash> cmCryptoHash::New(const char* algo)
{
if (strcmp(algo, "MD5") == 0) {
return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashMD5);
return CM_AUTO_PTR<cmCryptoHash>(new cmCryptoHashMD5);
} else if (strcmp(algo, "SHA1") == 0) {
return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA1);
return CM_AUTO_PTR<cmCryptoHash>(new cmCryptoHashSHA1);
} else if (strcmp(algo, "SHA224") == 0) {
return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA224);
return CM_AUTO_PTR<cmCryptoHash>(new cmCryptoHashSHA224);
} else if (strcmp(algo, "SHA256") == 0) {
return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA256);
return CM_AUTO_PTR<cmCryptoHash>(new cmCryptoHashSHA256);
} else if (strcmp(algo, "SHA384") == 0) {
return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA384);
return CM_AUTO_PTR<cmCryptoHash>(new cmCryptoHashSHA384);
} else if (strcmp(algo, "SHA512") == 0) {
return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA512);
return CM_AUTO_PTR<cmCryptoHash>(new cmCryptoHashSHA512);
} else {
return cmsys::auto_ptr<cmCryptoHash>(CM_NULLPTR);
return CM_AUTO_PTR<cmCryptoHash>(CM_NULLPTR);
}
}

4
Source/cmCryptoHash.h
View File

@ -14,13 +14,13 @@
#include "cmStandardIncludes.h"
#include <cmsys/auto_ptr.hxx>
#include <cm_auto_ptr.hxx>
class cmCryptoHash
{
public:
virtual ~cmCryptoHash() {}
static cmsys::auto_ptr<cmCryptoHash> New(const char* algo);
static CM_AUTO_PTR<cmCryptoHash> New(const char* algo);
std::string HashString(const std::string& input);
std::string HashFile(const std::string& file);

2
Source/cmCustomCommand.cxx
View File

@ -13,7 +13,7 @@
#include "cmMakefile.h"
#include <cmsys/auto_ptr.hxx>
#include <cm_auto_ptr.hxx>
cmCustomCommand::cmCustomCommand()
: Backtrace()

4
Source/cmCustomCommandGenerator.cxx
View File

@ -66,7 +66,7 @@ std::string cmCustomCommandGenerator::GetCommand(unsigned int c) const
}
}
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = this->GE->Parse(argv0);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = this->GE->Parse(argv0);
std::string exe = cge->Evaluate(this->LG, this->Config);
return exe;
@ -145,7 +145,7 @@ std::vector<std::string> const& cmCustomCommandGenerator::GetDepends() const
std::vector<std::string> depends = this->CC.GetDepends();
for (std::vector<std::string>::const_iterator i = depends.begin();
i != depends.end(); ++i) {
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = this->GE->Parse(*i);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = this->GE->Parse(*i);
std::vector<std::string> result;
cmSystemTools::ExpandListArgument(cge->Evaluate(this->LG, this->Config),
result);

13
Source/cmELF.cxx
View File

@ -13,8 +13,8 @@
#include "cmELF.h"
#include <cm_auto_ptr.hxx>
#include <cmsys/FStream.hxx>
#include <cmsys/auto_ptr.hxx>
// Include the ELF format information system header.
#if defined(__OpenBSD__)
@ -107,7 +107,7 @@ public:
};
// Construct and take ownership of the file stream object.
cmELFInternal(cmELF* external, cmsys::auto_ptr<cmsys::ifstream>& fin,
cmELFInternal(cmELF* external, CM_AUTO_PTR<cmsys::ifstream>& fin,
ByteOrderType order)
: External(external)
, Stream(*fin.release())
@ -237,7 +237,7 @@ public:
typedef typename Types::tagtype tagtype;
// Construct with a stream and byte swap indicator.
cmELFInternalImpl(cmELF* external, cmsys::auto_ptr<cmsys::ifstream>& fin,
cmELFInternalImpl(cmELF* external, CM_AUTO_PTR<cmsys::ifstream>& fin,
ByteOrderType order);
// Return the number of sections as specified by the ELF header.
@ -537,8 +537,9 @@ private:
};
template <class Types>
cmELFInternalImpl<Types>::cmELFInternalImpl(
cmELF* external, cmsys::auto_ptr<cmsys::ifstream>& fin, ByteOrderType order)
cmELFInternalImpl<Types>::cmELFInternalImpl(cmELF* external,
CM_AUTO_PTR<cmsys::ifstream>& fin,
ByteOrderType order)
: cmELFInternal(external, fin, order)
{
// Read the main header.
@ -755,7 +756,7 @@ cmELF::cmELF(const char* fname)
: Internal(CM_NULLPTR)
{
// Try to open the file.
cmsys::auto_ptr<cmsys::ifstream> fin(new cmsys::ifstream(fname));
CM_AUTO_PTR<cmsys::ifstream> fin(new cmsys::ifstream(fname));
// Quit now if the file could not be opened.
if (!fin.get() || !*fin) {

10
Source/cmExportFileGenerator.cxx
View File

@ -25,8 +25,8 @@
#include "cmVersion.h"
#include <assert.h>
#include <cm_auto_ptr.hxx>
#include <cmsys/FStream.hxx>
#include <cmsys/auto_ptr.hxx>
static std::string cmExportFileGeneratorEscape(std::string const& str)
{
@ -69,15 +69,15 @@ const char* cmExportFileGenerator::GetMainExportFileName() const
bool cmExportFileGenerator::GenerateImportFile()
{
// Open the output file to generate it.
cmsys::auto_ptr<cmsys::ofstream> foutPtr;
CM_AUTO_PTR<cmsys::ofstream> foutPtr;
if (this->AppendMode) {
// Open for append.
cmsys::auto_ptr<cmsys::ofstream> ap(
CM_AUTO_PTR<cmsys::ofstream> ap(
new cmsys::ofstream(this->MainImportFile.c_str(), std::ios::app));
foutPtr = ap;
} else {
// Generate atomically and with copy-if-different.
cmsys::auto_ptr<cmGeneratedFileStream> ap(
CM_AUTO_PTR<cmGeneratedFileStream> ap(
new cmGeneratedFileStream(this->MainImportFile.c_str(), true));
ap->SetCopyIfDifferent(true);
foutPtr = ap;
@ -393,7 +393,7 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface(
std::string dirs = cmGeneratorExpression::Preprocess(
tei->InterfaceIncludeDirectories, preprocessRule, true);
this->ReplaceInstallPrefix(dirs);
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(dirs);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(dirs);
std::string exportDirs =
cge->Evaluate(target->GetLocalGenerator(), "", false, target);

8
Source/cmExportLibraryDependenciesCommand.cxx
View File

@ -16,7 +16,7 @@
#include "cmVersion.h"
#include "cmake.h"
#include <cmsys/auto_ptr.hxx>
#include <cm_auto_ptr.hxx>
bool cmExportLibraryDependenciesCommand::InitialPass(
std::vector<std::string> const& args, cmExecutionStatus&)
@ -53,13 +53,13 @@ void cmExportLibraryDependenciesCommand::FinalPass()
void cmExportLibraryDependenciesCommand::ConstFinalPass() const
{
// Use copy-if-different if not appending.
cmsys::auto_ptr<cmsys::ofstream> foutPtr;
CM_AUTO_PTR<cmsys::ofstream> foutPtr;
if (this->Append) {
cmsys::auto_ptr<cmsys::ofstream> ap(
CM_AUTO_PTR<cmsys::ofstream> ap(
new cmsys::ofstream(this->Filename.c_str(), std::ios::app));
foutPtr = ap;
} else {
cmsys::auto_ptr<cmGeneratedFileStream> ap(
CM_AUTO_PTR<cmGeneratedFileStream> ap(
new cmGeneratedFileStream(this->Filename.c_str(), true));
ap->SetCopyIfDifferent(true);
foutPtr = ap;

2
Source/cmExportTryCompileFileGenerator.cxx
View File

@ -66,7 +66,7 @@ std::string cmExportTryCompileFileGenerator::FindTargets(
cmGeneratorExpressionDAGChecker dagChecker(tgt->GetName(), propName,
CM_NULLPTR, CM_NULLPTR);
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(prop);
cmTarget dummyHead;
dummyHead.SetType(cmState::EXECUTABLE, "try_compile_dummy_exe");

14
Source/cmFileCommand.cxx
View File

@ -34,12 +34,12 @@
// include sys/stat.h after sys/types.h
#include <sys/stat.h>
#include <cm_auto_ptr.hxx>
#include <cmsys/Directory.hxx>
#include <cmsys/Encoding.hxx>
#include <cmsys/FStream.hxx>
#include <cmsys/Glob.hxx>
#include <cmsys/RegularExpression.hxx>
#include <cmsys/auto_ptr.hxx>
// Table of permissions flags.
#if defined(_WIN32) && !defined(__CYGWIN__)
@ -330,7 +330,7 @@ bool cmFileCommand::HandleHashCommand(std::vector<std::string> const& args)
return false;
}
cmsys::auto_ptr<cmCryptoHash> hash(cmCryptoHash::New(args[0].c_str()));
CM_AUTO_PTR<cmCryptoHash> hash(cmCryptoHash::New(args[0].c_str()));
if (hash.get()) {
std::string out = hash->HashFile(args[1]);
if (!out.empty()) {
@ -2478,7 +2478,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
const char* cainfo = this->Makefile->GetDefinition("CMAKE_TLS_CAINFO");
std::string expectedHash;
std::string hashMatchMSG;
cmsys::auto_ptr<cmCryptoHash> hash;
CM_AUTO_PTR<cmCryptoHash> hash;
bool showProgress = false;
while (i != args.end()) {
@ -2534,7 +2534,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
this->SetError("DOWNLOAD missing sum value for EXPECTED_MD5.");
return false;
}
hash = cmsys::auto_ptr<cmCryptoHash>(cmCryptoHash::New("MD5"));
hash = CM_AUTO_PTR<cmCryptoHash>(cmCryptoHash::New("MD5"));
hashMatchMSG = "MD5 sum";
expectedHash = cmSystemTools::LowerCase(*i);
} else if (*i == "SHOW_PROGRESS") {
@ -2555,7 +2555,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
}
std::string algo = i->substr(0, pos);
expectedHash = cmSystemTools::LowerCase(i->substr(pos + 1));
hash = cmsys::auto_ptr<cmCryptoHash>(cmCryptoHash::New(algo.c_str()));
hash = CM_AUTO_PTR<cmCryptoHash>(cmCryptoHash::New(algo.c_str()));
if (!hash.get()) {
std::string err = "DOWNLOAD EXPECTED_HASH given unknown ALGO: ";
err += algo;
@ -2971,11 +2971,11 @@ void cmFileCommand::AddEvaluationFile(const std::string& inputName,
cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
cmGeneratorExpression outputGe(lfbt);
cmsys::auto_ptr<cmCompiledGeneratorExpression> outputCge =
CM_AUTO_PTR<cmCompiledGeneratorExpression> outputCge =
outputGe.Parse(outputExpr);
cmGeneratorExpression conditionGe(lfbt);
cmsys::auto_ptr<cmCompiledGeneratorExpression> conditionCge =
CM_AUTO_PTR<cmCompiledGeneratorExpression> conditionCge =
conditionGe.Parse(condition);
this->Makefile->AddEvaluationFile(inputName, outputCge, conditionCge,

33
Source/cmFindPackageCommand.cxx
View File

@ -1500,9 +1500,9 @@ void cmFindPackageCommand::StoreVersionFound()
this->Makefile->AddDefinition(ver + "_COUNT", buf);
}
#include <cm_auto_ptr.hxx>
#include <cmsys/Glob.hxx>
#include <cmsys/String.h>
#include <cmsys/auto_ptr.hxx>
class cmFileList;
class cmFileListGeneratorBase
@ -1515,10 +1515,10 @@ protected:
private:
bool Search(cmFileList&);
virtual bool Search(std::string const& parent, cmFileList&) = 0;
virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const = 0;
virtual CM_AUTO_PTR<cmFileListGeneratorBase> Clone() const = 0;
friend class cmFileList;
cmFileListGeneratorBase* SetNext(cmFileListGeneratorBase const& next);
cmsys::auto_ptr<cmFileListGeneratorBase> Next;
CM_AUTO_PTR<cmFileListGeneratorBase> Next;
};
class cmFileList
@ -1551,7 +1551,7 @@ public:
private:
virtual bool Visit(std::string const& fullPath) = 0;
friend class cmFileListGeneratorBase;
cmsys::auto_ptr<cmFileListGeneratorBase> First;
CM_AUTO_PTR<cmFileListGeneratorBase> First;
cmFileListGeneratorBase* Last;
};
@ -1621,9 +1621,9 @@ private:
std::string fullPath = parent + this->String;
return this->Consider(fullPath, lister);
}
cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
CM_AUTO_PTR<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
{
cmsys::auto_ptr<cmFileListGeneratorBase> g(
CM_AUTO_PTR<cmFileListGeneratorBase> g(
new cmFileListGeneratorFixed(*this));
return g;
}
@ -1655,9 +1655,9 @@ private:
}
return false;
}
cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
CM_AUTO_PTR<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
{
cmsys::auto_ptr<cmFileListGeneratorBase> g(
CM_AUTO_PTR<cmFileListGeneratorBase> g(
new cmFileListGeneratorEnumerate(*this));
return g;
}
@ -1706,9 +1706,9 @@ private:
}
return false;
}
cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
CM_AUTO_PTR<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
{
cmsys::auto_ptr<cmFileListGeneratorBase> g(
CM_AUTO_PTR<cmFileListGeneratorBase> g(
new cmFileListGeneratorProject(*this));
return g;
}
@ -1763,9 +1763,9 @@ private:
}
return false;
}
cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
CM_AUTO_PTR<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
{
cmsys::auto_ptr<cmFileListGeneratorBase> g(
CM_AUTO_PTR<cmFileListGeneratorBase> g(
new cmFileListGeneratorMacProject(*this));
return g;
}
@ -1807,9 +1807,9 @@ private:
}
return false;
}
cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
CM_AUTO_PTR<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
{
cmsys::auto_ptr<cmFileListGeneratorBase> g(
CM_AUTO_PTR<cmFileListGeneratorBase> g(
new cmFileListGeneratorCaseInsensitive(*this));
return g;
}
@ -1853,10 +1853,9 @@ private:
}
return false;
}
cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
CM_AUTO_PTR<cmFileListGeneratorBase> Clone() const CM_OVERRIDE
{
cmsys::auto_ptr<cmFileListGeneratorBase> g(
new cmFileListGeneratorGlob(*this));
CM_AUTO_PTR<cmFileListGeneratorBase> g(new cmFileListGeneratorGlob(*this));
return g;
}
};

7
Source/cmForEachCommand.cxx
View File

@ -11,7 +11,7 @@
============================================================================*/
#include "cmForEachCommand.h"
#include <cmsys/auto_ptr.hxx>
#include <cm_auto_ptr.hxx>
cmForEachFunctionBlocker::cmForEachFunctionBlocker(cmMakefile* mf)
: Makefile(mf)
@ -36,8 +36,7 @@ bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
// if this is the endofreach for this statement
if (!this->Depth) {
// Remove the function blocker for this scope or bail.
cmsys::auto_ptr<cmFunctionBlocker> fb(
mf.RemoveFunctionBlocker(this, lff));
CM_AUTO_PTR<cmFunctionBlocker> fb(mf.RemoveFunctionBlocker(this, lff));
if (!fb.get()) {
return false;
}
@ -184,7 +183,7 @@ bool cmForEachCommand::InitialPass(std::vector<std::string> const& args,
bool cmForEachCommand::HandleInMode(std::vector<std::string> const& args)
{
cmsys::auto_ptr<cmForEachFunctionBlocker> f(
CM_AUTO_PTR<cmForEachFunctionBlocker> f(
new cmForEachFunctionBlocker(this->Makefile));
f->Args.push_back(args[0]);

6
Source/cmGeneratorExpression.cxx
View File

@ -26,14 +26,14 @@ cmGeneratorExpression::cmGeneratorExpression(
{
}
cmsys::auto_ptr<cmCompiledGeneratorExpression> cmGeneratorExpression::Parse(
CM_AUTO_PTR<cmCompiledGeneratorExpression> cmGeneratorExpression::Parse(
std::string const& input)
{
return cmsys::auto_ptr<cmCompiledGeneratorExpression>(
return CM_AUTO_PTR<cmCompiledGeneratorExpression>(
new cmCompiledGeneratorExpression(this->Backtrace, input));
}
cmsys::auto_ptr<cmCompiledGeneratorExpression> cmGeneratorExpression::Parse(
CM_AUTO_PTR<cmCompiledGeneratorExpression> cmGeneratorExpression::Parse(
const char* input)
{
return this->Parse(std::string(input ? input : ""));

7
Source/cmGeneratorExpression.h
View File

@ -17,8 +17,8 @@
#include "cmListFileCache.h"
#include <cm_auto_ptr.hxx>
#include <cmsys/RegularExpression.hxx>
#include <cmsys/auto_ptr.hxx>
class cmGeneratorTarget;
class cmLocalGenerator;
@ -47,9 +47,8 @@ public:
cmListFileBacktrace const& backtrace = cmListFileBacktrace());
~cmGeneratorExpression();
cmsys::auto_ptr<cmCompiledGeneratorExpression> Parse(
std::string const& input);
cmsys::auto_ptr<cmCompiledGeneratorExpression> Parse(const char* input);
CM_AUTO_PTR<cmCompiledGeneratorExpression> Parse(std::string const& input);
CM_AUTO_PTR<cmCompiledGeneratorExpression> Parse(const char* input);
enum PreprocessContext
{

7
Source/cmGeneratorExpressionEvaluationFile.cxx
View File

@ -23,9 +23,8 @@
cmGeneratorExpressionEvaluationFile::cmGeneratorExpressionEvaluationFile(
const std::string& input,
cmsys::auto_ptr<cmCompiledGeneratorExpression> outputFileExpr,
cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
bool inputIsContent)
CM_AUTO_PTR<cmCompiledGeneratorExpression> outputFileExpr,
CM_AUTO_PTR<cmCompiledGeneratorExpression> condition, bool inputIsContent)
: Input(input)
, OutputFileExpr(outputFileExpr)
, Condition(condition)
@ -135,7 +134,7 @@ void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator* lg)
cmListFileBacktrace lfbt = this->OutputFileExpr->GetBacktrace();
cmGeneratorExpression contentGE(lfbt);
cmsys::auto_ptr<cmCompiledGeneratorExpression> inputExpression =
CM_AUTO_PTR<cmCompiledGeneratorExpression> inputExpression =
contentGE.Parse(inputContent);
std::map<std::string, std::string> outputFiles;

11
Source/cmGeneratorExpressionEvaluationFile.h
View File

@ -14,7 +14,7 @@
#include "cmGeneratorExpression.h"
#include <cmsys/auto_ptr.hxx>
#include <cm_auto_ptr.hxx>
#include <sys/types.h>
class cmLocalGenerator;
@ -24,9 +24,8 @@ class cmGeneratorExpressionEvaluationFile
public:
cmGeneratorExpressionEvaluationFile(
const std::string& input,
cmsys::auto_ptr<cmCompiledGeneratorExpression> outputFileExpr,
cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
bool inputIsContent);
CM_AUTO_PTR<cmCompiledGeneratorExpression> outputFileExpr,
CM_AUTO_PTR<cmCompiledGeneratorExpression> condition, bool inputIsContent);
void Generate(cmLocalGenerator* lg);
@ -42,8 +41,8 @@ private:
private:
const std::string Input;
const cmsys::auto_ptr<cmCompiledGeneratorExpression> OutputFileExpr;
const cmsys::auto_ptr<cmCompiledGeneratorExpression> Condition;
const CM_AUTO_PTR<cmCompiledGeneratorExpression> OutputFileExpr;
const CM_AUTO_PTR<cmCompiledGeneratorExpression> Condition;
std::vector<std::string> Files;
const bool InputIsContent;
};

2
Source/cmGeneratorExpressionNode.cxx
View File

@ -24,7 +24,7 @@ std::string cmGeneratorExpressionNode::EvaluateDependentExpression(
cmGeneratorExpressionDAGChecker* dagChecker)
{
cmGeneratorExpression ge(context->Backtrace);
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(prop);
cge->SetEvaluateForBuildsystem(context->EvaluateForBuildsystem);
std::string result =
cge->Evaluate(lg, context->Config, context->Quiet, headTarget,

30
Source/cmGeneratorTarget.cxx
View File

@ -42,13 +42,13 @@ class cmGeneratorTarget::TargetPropertyEntry
static cmLinkImplItem NoLinkImplItem;
public:
TargetPropertyEntry(cmsys::auto_ptr<cmCompiledGeneratorExpression> cge,
TargetPropertyEntry(CM_AUTO_PTR<cmCompiledGeneratorExpression> cge,
cmLinkImplItem const& item = NoLinkImplItem)
: ge(cge)
, LinkImplItem(item)
{
}
const cmsys::auto_ptr<cmCompiledGeneratorExpression> ge;
const CM_AUTO_PTR<cmCompiledGeneratorExpression> ge;
cmLinkImplItem const& LinkImplItem;
};
cmLinkImplItem cmGeneratorTarget::TargetPropertyEntry::NoLinkImplItem;
@ -253,7 +253,7 @@ void CreatePropertyGeneratorExpressions(
for (std::vector<std::string>::const_iterator it = entries.begin();
it != entries.end(); ++it, ++btIt) {
cmGeneratorExpression ge(*btIt);
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*it);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(*it);
cge->SetEvaluateForBuildsystem(evaluateForBuildsystem);
items.push_back(new cmGeneratorTarget::TargetPropertyEntry(cge));
}
@ -443,7 +443,7 @@ std::string cmGeneratorTarget::GetOutputName(const std::string& config,
// Now evaluate genex and update the previously-prepared map entry.
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outName);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(outName);
i->second = cge->Evaluate(this->LocalGenerator, config);
} else if (i->second.empty()) {
// An empty map entry indicates we have been called recursively
@ -461,7 +461,7 @@ void cmGeneratorTarget::AddSource(const std::string& src)
this->Target->AddSource(src);
cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
cmGeneratorExpression ge(lfbt);
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(src);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(src);
cge->SetEvaluateForBuildsystem(true);
this->SourceEntries.push_back(new TargetPropertyEntry(cge));
this->SourceFilesMap.clear();
@ -477,7 +477,7 @@ void cmGeneratorTarget::AddTracedSources(std::vector<std::string> const& srcs)
this->LinkImplementationLanguageIsContextDependent = true;
cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
cmGeneratorExpression ge(lfbt);
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(srcFiles);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(srcFiles);
cge->SetEvaluateForBuildsystem(true);
this->SourceEntries.push_back(
new cmGeneratorTarget::TargetPropertyEntry(cge));
@ -862,7 +862,7 @@ static void AddInterfaceEntries(
if (it->Target) {
std::string genex = "$<TARGET_PROPERTY:" + *it + "," + prop + ">";
cmGeneratorExpression ge(it->Backtrace);
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(genex);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(genex);
cge->SetEvaluateForBuildsystem(true);
entries.push_back(
new cmGeneratorTarget::TargetPropertyEntry(cge, *it));
@ -2119,8 +2119,7 @@ void cmTargetTraceDependencies::CheckCustomCommand(cmCustomCommand const& cc)
// Check for target references in generator expressions.
for (cmCustomCommandLine::const_iterator cli = cit->begin();
cli != cit->end(); ++cli) {
const cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(*cli);
const CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(*cli);
cge->Evaluate(this->GeneratorTarget->GetLocalGenerator(), "", true);
std::set<cmGeneratorTarget*> geTargets = cge->GetTargets();
targets.insert(geTargets.begin(), geTargets.end());
@ -2405,7 +2404,7 @@ std::vector<std::string> cmGeneratorTarget::GetIncludeDirectories(
libDir = frameworkCheck.match(1);
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge =
ge.Parse(libDir.c_str());
linkInterfaceIncludeDirectoriesEntries.push_back(
new cmGeneratorTarget::TargetPropertyEntry(cge));
@ -2629,7 +2628,7 @@ void cmGeneratorTarget::GetCompileDefinitions(
}
case cmPolicies::OLD: {
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge =
ge.Parse(configProp);
linkInterfaceCompileDefinitionsEntries.push_back(
new cmGeneratorTarget::TargetPropertyEntry(cge));
@ -3981,7 +3980,7 @@ void cmGeneratorTarget::ExpandLinkItems(
dagChecker.SetTransitivePropertiesOnly();
}
std::vector<std::string> libs;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(value);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(value);
cmSystemTools::ExpandListArgument(cge->Evaluate(this->LocalGenerator, config,
false, headTarget, this,
&dagChecker),
@ -4246,8 +4245,7 @@ bool cmGeneratorTarget::ComputeOutputDir(const std::string& config,
if (const char* config_outdir = this->GetProperty(configProp)) {
// Use the user-specified per-configuration output directory.
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(config_outdir);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(config_outdir);
out = cge->Evaluate(this->LocalGenerator, config);
// Skip per-configuration subdirectory.
@ -4255,7 +4253,7 @@ bool cmGeneratorTarget::ComputeOutputDir(const std::string& config,
} else if (const char* outdir = this->GetProperty(propertyName)) {
// Use the user-specified output directory.
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outdir);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(outdir);
out = cge->Evaluate(this->LocalGenerator, config);
// Skip per-configuration subdirectory if the value contained a
@ -4990,7 +4988,7 @@ void cmGeneratorTarget::ComputeLinkImplementationLibraries(
cmGeneratorExpressionDAGChecker dagChecker(
this->GetName(), "LINK_LIBRARIES", CM_NULLPTR, CM_NULLPTR);
cmGeneratorExpression ge(*btIt);
cmsys::auto_ptr<cmCompiledGeneratorExpression> const cge = ge.Parse(*le);
CM_AUTO_PTR<cmCompiledGeneratorExpression> const cge = ge.Parse(*le);
std::string const evaluated =
cge->Evaluate(this->LocalGenerator, config, false, head, &dagChecker);
cmSystemTools::ExpandListArgument(evaluated, llibs);

2
Source/cmGlobalVisualStudio7Generator.cxx
View File

@ -674,7 +674,7 @@ std::set<std::string> cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild(
target->Target->GetMakefile()->GetDefinition(
"CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD");
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge =
ge.Parse(propertyValue);
if (cmSystemTools::IsOn(
cge->Evaluate(target->GetLocalGenerator(), *i))) {

4
Source/cmGlobalXCodeGenerator.cxx
View File

@ -24,7 +24,7 @@
#include "cmXCodeObject.h"
#include "cmake.h"
#include <cmsys/auto_ptr.hxx>
#include <cm_auto_ptr.hxx>
#if defined(CMAKE_BUILD_WITH_CMAKE)
#include "cmXMLParser.h"
@ -175,7 +175,7 @@ cmGlobalGenerator* cmGlobalXCodeGenerator::Factory::CreateGlobalGenerator(
parser.ParseFile(
"/Developer/Applications/Xcode.app/Contents/version.plist");
}
cmsys::auto_ptr<cmGlobalXCodeGenerator> gg(
CM_AUTO_PTR<cmGlobalXCodeGenerator> gg(
new cmGlobalXCodeGenerator(cm, parser.Version));
if (gg->XcodeVersion == 20) {
cmSystemTools::Message("Xcode 2.0 not really supported by cmake, "

5
Source/cmGraphVizWriter.cxx
View File

@ -64,9 +64,8 @@ void cmGraphVizWriter::ReadSettings(const char* settingsFileName,
cm.SetHomeOutputDirectory("");
cm.GetCurrentSnapshot().SetDefaultDefinitions();
cmGlobalGenerator ggi(&cm);
cmsys::auto_ptr<cmMakefile> mf(
new cmMakefile(&ggi, cm.GetCurrentSnapshot()));
cmsys::auto_ptr<cmLocalGenerator> lg(ggi.CreateLocalGenerator(mf.get()));
CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(&ggi, cm.GetCurrentSnapshot()));
CM_AUTO_PTR<cmLocalGenerator> lg(ggi.CreateLocalGenerator(mf.get()));
const char* inFileName = settingsFileName;

3
Source/cmIfCommand.cxx
View File

@ -46,8 +46,7 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
// if this is the endif for this if statement, then start executing
if (!this->ScopeDepth) {
// Remove the function blocker for this scope or bail.
cmsys::auto_ptr<cmFunctionBlocker> fb(
mf.RemoveFunctionBlocker(this, lff));
CM_AUTO_PTR<cmFunctionBlocker> fb(mf.RemoveFunctionBlocker(this, lff));
if (!fb.get()) {
return false;
}

2
Source/cmInstallDirectoryGenerator.cxx
View File

@ -69,7 +69,7 @@ void cmInstallDirectoryGenerator::GenerateScriptForConfig(
cmGeneratorExpression ge;
for (std::vector<std::string>::const_iterator i = this->Directories.begin();
i != this->Directories.end(); ++i) {
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*i);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(*i);
cmSystemTools::ExpandListArgument(
cge->Evaluate(this->LocalGenerator, config), dirs);
}

2
Source/cmInstallFilesGenerator.cxx
View File

@ -90,7 +90,7 @@ void cmInstallFilesGenerator::GenerateScriptForConfig(
cmGeneratorExpression ge;
for (std::vector<std::string>::const_iterator i = this->Files.begin();
i != this->Files.end(); ++i) {
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*i);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(*i);
cmSystemTools::ExpandListArgument(
cge->Evaluate(this->LocalGenerator, config), files);
}

2
Source/cmInstalledFile.h
View File

@ -22,7 +22,7 @@
class cmInstalledFile
{
public:
typedef cmsys::auto_ptr<cmCompiledGeneratorExpression>
typedef CM_AUTO_PTR<cmCompiledGeneratorExpression>
CompiledGeneratorExpressionPtrType;
typedef std::vector<cmCompiledGeneratorExpression*> ExpressionVectorType;

4
Source/cmLocalUnixMakefileGenerator3.cxx
View File

@ -30,8 +30,8 @@
#include "cmDependsJava.h"
#endif
#include <cm_auto_ptr.hxx>
#include <cmsys/Terminal.h>
#include <cmsys/auto_ptr.hxx>
#include <algorithm>
#include <queue>
@ -121,7 +121,7 @@ void cmLocalUnixMakefileGenerator3::Generate()
if ((*t)->GetType() == cmState::INTERFACE_LIBRARY) {
continue;
}
cmsys::auto_ptr<cmMakefileTargetGenerator> tg(
CM_AUTO_PTR<cmMakefileTargetGenerator> tg(
cmMakefileTargetGenerator::New(*t));
if (tg.get()) {
tg->WriteRuleFiles();

2
Source/cmLocalVisualStudio7Generator.cxx
View File

@ -1850,7 +1850,7 @@ void cmLocalVisualStudio7Generator::OutputTargetRules(
if (!addedPrelink) {
event.Write(target->GetPreLinkCommands());
}
cmsys::auto_ptr<cmCustomCommand> pcc(
CM_AUTO_PTR<cmCustomCommand> pcc(
this->MaybeCreateImplibDir(target, configName, this->FortranProject));
if (pcc.get()) {
event.Write(*pcc);

4
Source/cmLocalVisualStudioGenerator.cxx
View File

@ -74,12 +74,12 @@ void cmLocalVisualStudioGenerator::ComputeObjectFilenames(
}
}
cmsys::auto_ptr<cmCustomCommand>
CM_AUTO_PTR<cmCustomCommand>
cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmGeneratorTarget* target,
const std::string& config,
bool isFortran)
{
cmsys::auto_ptr<cmCustomCommand> pcc;
CM_AUTO_PTR<cmCustomCommand> pcc;
// If an executable exports symbols then VS wants to create an
// import library but forgets to create the output directory.

7
Source/cmLocalVisualStudioGenerator.h
View File

@ -16,7 +16,7 @@
#include "cmGlobalVisualStudioGenerator.h"
#include <cmsys/auto_ptr.hxx>
#include <cm_auto_ptr.hxx>
class cmSourceFile;
class cmSourceGroup;
@ -59,8 +59,9 @@ protected:
virtual bool CustomCommandUseLocal() const { return false; }
/** Construct a custom command to make exe import lib dir. */
cmsys::auto_ptr<cmCustomCommand> MaybeCreateImplibDir(
cmGeneratorTarget* target, const std::string& config, bool isFortran);
CM_AUTO_PTR<cmCustomCommand> MaybeCreateImplibDir(cmGeneratorTarget* target,
const std::string& config,
bool isFortran);
};
#endif

19
Source/cmMakefile.cxx
View File

@ -35,10 +35,10 @@
#include "cmake.h"
#include <stdlib.h> // required for atoi
#include <cm_auto_ptr.hxx>
#include <cmsys/FStream.hxx>
#include <cmsys/RegularExpression.hxx>
#include <cmsys/SystemTools.hxx>
#include <cmsys/auto_ptr.hxx>
#include <assert.h>
#include <ctype.h> // for isspace
@ -262,7 +262,7 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff,
// Lookup the command prototype.
if (cmCommand* proto = this->GetState()->GetCommand(name)) {
// Clone the prototype.
cmsys::auto_ptr<cmCommand> pcmd(proto->Clone());
CM_AUTO_PTR<cmCommand> pcmd(proto->Clone());
pcmd->SetMakefile(this);
// Decide whether to invoke the command.
@ -589,9 +589,8 @@ void cmMakefile::EnforceDirectoryLevelRules() const
void cmMakefile::AddEvaluationFile(
const std::string& inputFile,
cmsys::auto_ptr<cmCompiledGeneratorExpression> outputName,
cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
bool inputIsContent)
CM_AUTO_PTR<cmCompiledGeneratorExpression> outputName,
CM_AUTO_PTR<cmCompiledGeneratorExpression> condition, bool inputIsContent)
{
this->EvaluationFiles.push_back(new cmGeneratorExpressionEvaluationFile(
inputFile, outputName, condition, inputIsContent));
@ -2890,7 +2889,7 @@ void cmMakefile::PopFunctionBlockerBarrier(bool reportError)
FunctionBlockersType::size_type barrier =
this->FunctionBlockerBarriers.back();
while (this->FunctionBlockers.size() > barrier) {
cmsys::auto_ptr<cmFunctionBlocker> fb(this->FunctionBlockers.back());
CM_AUTO_PTR<cmFunctionBlocker> fb(this->FunctionBlockers.back());
this->FunctionBlockers.pop_back();
if (reportError) {
// Report the context in which the unclosed block was opened.
@ -3027,7 +3026,7 @@ void cmMakefile::AddFunctionBlocker(cmFunctionBlocker* fb)
this->FunctionBlockers.push_back(fb);
}
cmsys::auto_ptr<cmFunctionBlocker> cmMakefile::RemoveFunctionBlocker(
CM_AUTO_PTR<cmFunctionBlocker> cmMakefile::RemoveFunctionBlocker(
cmFunctionBlocker* fb, const cmListFileFunction& lff)
{
// Find the function blocker stack barrier for the current scope.
@ -3060,11 +3059,11 @@ cmsys::auto_ptr<cmFunctionBlocker> cmMakefile::RemoveFunctionBlocker(
}
cmFunctionBlocker* b = *pos;
this->FunctionBlockers.erase(pos);
return cmsys::auto_ptr<cmFunctionBlocker>(b);
return CM_AUTO_PTR<cmFunctionBlocker>(b);
}
}
return cmsys::auto_ptr<cmFunctionBlocker>();
return CM_AUTO_PTR<cmFunctionBlocker>();
}
const char* cmMakefile::GetHomeDirectory() const
@ -3692,7 +3691,7 @@ cmTarget* cmMakefile::AddImportedTarget(const std::string& name,
cmState::TargetType type, bool global)
{
// Create the target.
cmsys::auto_ptr<cmTarget> target(new cmTarget);
CM_AUTO_PTR<cmTarget> target(new cmTarget);
target->SetType(type, name);
target->MarkAsImported(global);
target->SetMakefile(this);

13
Source/cmMakefile.h
View File

@ -28,8 +28,8 @@
#include "cmSourceGroup.h"
#endif
#include <cm_auto_ptr.hxx>
#include <cmsys/RegularExpression.hxx>
#include <cmsys/auto_ptr.hxx>
#if defined(CMAKE_BUILD_WITH_CMAKE)
#ifdef CMake_HAVE_CXX_UNORDERED_MAP
#include <unordered_map>
@ -97,7 +97,7 @@ public:
* Remove the function blocker whose scope ends with the given command.
* This returns ownership of the function blocker object.
*/
cmsys::auto_ptr<cmFunctionBlocker> RemoveFunctionBlocker(
CM_AUTO_PTR<cmFunctionBlocker> RemoveFunctionBlocker(
cmFunctionBlocker* fb, const cmListFileFunction& lff);
/**
@ -771,11 +771,10 @@ public:
void EnforceDirectoryLevelRules() const;
void AddEvaluationFile(
const std::string& inputFile,
cmsys::auto_ptr<cmCompiledGeneratorExpression> outputName,
cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
bool inputIsContent);
void AddEvaluationFile(const std::string& inputFile,
CM_AUTO_PTR<cmCompiledGeneratorExpression> outputName,
CM_AUTO_PTR<cmCompiledGeneratorExpression> condition,
bool inputIsContent);
std::vector<cmGeneratorExpressionEvaluationFile*> GetEvaluationFiles() const;
std::vector<cmExportBuildFileGenerator*> GetExportBuildFileGenerators()

2
Source/cmMakefileTargetGenerator.cxx
View File

@ -134,7 +134,7 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
if (const char* additional_clean_files =
this->Makefile->GetProperty("ADDITIONAL_MAKE_CLEAN_FILES")) {
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge =
ge.Parse(additional_clean_files);
cmSystemTools::ExpandListArgument(

2
Source/cmQtAutoGenerators.cxx
View File

@ -155,7 +155,7 @@ bool cmQtAutoGenerators::Run(const std::string& targetDirectory,
snapshot.GetDirectory().SetCurrentBinary(targetDirectory);
snapshot.GetDirectory().SetCurrentSource(targetDirectory);
cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, snapshot));
CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(&gg, snapshot));
gg.SetCurrentMakefile(mf.get());
this->ReadAutogenInfoFile(mf.get(), targetDirectory, config);

2
Source/cmStringCommand.cxx
View File

@ -89,7 +89,7 @@ bool cmStringCommand::HandleHashCommand(std::vector<std::string> const& args)
return false;
}
cmsys::auto_ptr<cmCryptoHash> hash(cmCryptoHash::New(args[0].c_str()));
CM_AUTO_PTR<cmCryptoHash> hash(cmCryptoHash::New(args[0].c_str()));
if (hash.get()) {
std::string out = hash->HashString(args[2]);
this->Makefile->AddDefinition(args[1], out.c_str());

2
Source/cmTarget.h
View File

@ -19,7 +19,7 @@
#include "cmPolicies.h"
#include "cmPropertyMap.h"
#include <cmsys/auto_ptr.hxx>
#include <cm_auto_ptr.hxx>
#if defined(CMAKE_BUILD_WITH_CMAKE)
#ifdef CMake_HAVE_CXX_UNORDERED_MAP
#include <unordered_map>

4
Source/cmVariableWatch.cxx
View File

@ -13,7 +13,7 @@
#include "cmAlgorithms.h"
#include <cmsys/auto_ptr.hxx>
#include <cm_auto_ptr.hxx>
static const char* const cmVariableWatchAccessStrings[] = {
"READ_ACCESS", "UNKNOWN_READ_ACCESS", "UNKNOWN_DEFINED_ACCESS",
@ -48,7 +48,7 @@ bool cmVariableWatch::AddWatch(const std::string& variable, WatchMethod method,
void* client_data /*=0*/,
DeleteData delete_data /*=0*/)
{
cmsys::auto_ptr<cmVariableWatch::Pair> p(new cmVariableWatch::Pair);
CM_AUTO_PTR<cmVariableWatch::Pair> p(new cmVariableWatch::Pair);
p->Method = method;
p->ClientData = client_data;
p->DeleteDataCall = delete_data;

19
Source/cmVisualStudio10TargetGenerator.cxx
View File

@ -42,7 +42,7 @@
#include "cmVisualStudioGeneratorOptions.h"
#include "windows.h"
#include <cmsys/auto_ptr.hxx>
#include <cm_auto_ptr.hxx>
cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetClFlagTable() const
{
@ -1229,8 +1229,7 @@ void cmVisualStudio10TargetGenerator::WriteExtraSource(cmSourceFile const* sf)
if (!deployContent.empty()) {
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
ge.Parse(deployContent);
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(deployContent);
// Deployment location cannot be set on a configuration basis
if (!deployLocation.empty()) {
this->WriteString("<Link>", 3);
@ -1684,7 +1683,7 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions(
// copied from cmLocalVisualStudio7Generator.cxx 805
// TODO: Integrate code below with cmLocalVisualStudio7Generator.
cmsys::auto_ptr<Options> pOptions(new Options(
CM_AUTO_PTR<Options> pOptions(new Options(
this->LocalGenerator, Options::Compiler, this->GetClFlagTable()));
Options& clOptions = *pOptions;
@ -1848,7 +1847,7 @@ bool cmVisualStudio10TargetGenerator::ComputeRcOptions()
bool cmVisualStudio10TargetGenerator::ComputeRcOptions(
std::string const& configName)
{
cmsys::auto_ptr<Options> pOptions(new Options(
CM_AUTO_PTR<Options> pOptions(new Options(
this->LocalGenerator, Options::ResourceCompiler, this->GetRcFlagTable()));
Options& rcOptions = *pOptions;
@ -1905,7 +1904,7 @@ bool cmVisualStudio10TargetGenerator::ComputeMasmOptions()
bool cmVisualStudio10TargetGenerator::ComputeMasmOptions(
std::string const& configName)
{
cmsys::auto_ptr<Options> pOptions(new Options(
CM_AUTO_PTR<Options> pOptions(new Options(
this->LocalGenerator, Options::MasmCompiler, this->GetMasmFlagTable()));
Options& masmOptions = *pOptions;
@ -2058,7 +2057,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
if (const char* nativeLibDirectoriesExpression =
this->GeneratorTarget->GetProperty("ANDROID_NATIVE_LIB_DIRECTORIES")) {
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge =
ge.Parse(nativeLibDirectoriesExpression);
std::string nativeLibDirs =
cge->Evaluate(this->LocalGenerator, configName);
@ -2071,7 +2070,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
this->GeneratorTarget->GetProperty(
"ANDROID_NATIVE_LIB_DEPENDENCIES")) {
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge =
ge.Parse(nativeLibDependenciesExpression);
std::string nativeLibDeps =
cge->Evaluate(this->LocalGenerator, configName);
@ -2090,7 +2089,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions(
if (const char* jarDirectoriesExpression =
this->GeneratorTarget->GetProperty("ANDROID_JAR_DIRECTORIES")) {
cmGeneratorExpression ge;
cmsys::auto_ptr<cmCompiledGeneratorExpression> cge =
CM_AUTO_PTR<cmCompiledGeneratorExpression> cge =
ge.Parse(jarDirectoriesExpression);
std::string jarDirectories =
cge->Evaluate(this->LocalGenerator, configName);
@ -2150,7 +2149,7 @@ bool cmVisualStudio10TargetGenerator::ComputeLinkOptions()
bool cmVisualStudio10TargetGenerator::ComputeLinkOptions(
std::string const& config)
{
cmsys::auto_ptr<Options> pOptions(new Options(
CM_AUTO_PTR<Options> pOptions(new Options(
this->LocalGenerator, Options::Linker, this->GetLinkFlagTable(), 0, this));
Options& linkOptions = *pOptions;

3
Source/cmWhileCommand.cxx
View File

@ -37,8 +37,7 @@ bool cmWhileFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
// if this is the endwhile for this while loop then execute
if (!this->Depth) {
// Remove the function blocker for this scope or bail.
cmsys::auto_ptr<cmFunctionBlocker> fb(
mf.RemoveFunctionBlocker(this, lff));
CM_AUTO_PTR<cmFunctionBlocker> fb(mf.RemoveFunctionBlocker(this, lff));
if (!fb.get()) {
return false;
}

221
Source/cm_auto_ptr.hxx Normal file
View File

@ -0,0 +1,221 @@
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2016 Kitware, Inc.
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#ifndef CM_AUTO_PTR_HXX
#define CM_AUTO_PTR_HXX
#include <cmsys/Configure.hxx>
// FIXME: Use std::auto_ptr on compilers that do not warn about it.
#define CM_AUTO_PTR cm::auto_ptr
// The HP compiler cannot handle the conversions necessary to use
// auto_ptr_ref to pass an auto_ptr returned from one function
// directly to another function as in use_auto_ptr(get_auto_ptr()).
// We instead use const_cast to achieve the syntax on those platforms.
// We do not use const_cast on other platforms to maintain the C++
// standard design and guarantee that if an auto_ptr is bound
// to a reference-to-const then ownership will be maintained.
#if defined(__HP_aCC)
#define cm_AUTO_PTR_REF 0
#define cm_AUTO_PTR_CONST const
#define cm_AUTO_PTR_CAST(a) cast(a)
#else
#define cm_AUTO_PTR_REF 1
#define cm_AUTO_PTR_CONST
#define cm_AUTO_PTR_CAST(a) a
#endif
// In C++11, clang will warn about using dynamic exception specifications
// as they are deprecated. But as this class is trying to faithfully
// mimic std::auto_ptr, we want to keep the 'throw()' decorations below.
// So we suppress the warning.
#if defined(__clang__) && defined(__has_warning)
#if __has_warning("-Wdeprecated")
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdeprecated"
#endif
#endif
namespace cm {
template <class X>
class auto_ptr;
#if cm_AUTO_PTR_REF
namespace detail {
// The auto_ptr_ref template is supposed to be a private member of
// auto_ptr but Borland 5.8 cannot handle it. Instead put it in
// a private namespace.
template <class Y>
struct auto_ptr_ref
{
Y* p_;
// The extra constructor argument prevents implicit conversion to
// auto_ptr_ref from auto_ptr through the constructor. Normally
// this should be done with the explicit keyword but Borland 5.x
// generates code in the conversion operator to call itself
// infinately.
auto_ptr_ref(Y* p, int)
: p_(p)
{
}
};
}
#endif
/** C++98 Standard Section 20.4.5 - Template class auto_ptr. */
template <class X>
class auto_ptr
{
#if !cm_AUTO_PTR_REF
template <typename Y>
static inline auto_ptr<Y>& cast(auto_ptr<Y> const& a)
{
return const_cast<auto_ptr<Y>&>(a);
}
#endif
/** The pointer to the object held. */
X* x_;
public:
/** The type of object held by the auto_ptr. */
typedef X element_type;
/** Construct from an auto_ptr holding a compatible object. This
transfers ownership to the newly constructed auto_ptr. */
template <class Y>
auto_ptr(auto_ptr<Y> cm_AUTO_PTR_CONST& a) throw()
: x_(cm_AUTO_PTR_CAST(a).release())
{
}
/** Assign from an auto_ptr holding a compatible object. This
transfers ownership to the left-hand-side of the assignment. */
template <class Y>
auto_ptr& operator=(auto_ptr<Y> cm_AUTO_PTR_CONST& a) throw()
{
this->reset(cm_AUTO_PTR_CAST(a).release());
return *this;
}
/**
* Explicitly construct from a raw pointer. This is typically
* called with the result of operator new. For example:
*
* auto_ptr<X> ptr(new X());
*/
explicit auto_ptr(X* p = 0) throw()
: x_(p)
{
}
/** Construct from another auto_ptr holding an object of the same
type. This transfers ownership to the newly constructed
auto_ptr. */
auto_ptr(auto_ptr cm_AUTO_PTR_CONST& a) throw()
: x_(cm_AUTO_PTR_CAST(a).release())
{
}
/** Assign from another auto_ptr holding an object of the same type.
This transfers ownership to the newly constructed auto_ptr. */
auto_ptr& operator=(auto_ptr cm_AUTO_PTR_CONST& a) throw()
{
this->reset(cm_AUTO_PTR_CAST(a).release());
return *this;
}
/** Destruct and delete the object held. */
~auto_ptr() throw()
{
// Assume object destructor is nothrow.
delete this->x_;
}
/** Dereference and return a reference to the object held. */
X& operator*() const throw() { return *this->x_; }
/** Return a pointer to the object held. */
X* operator->() const throw() { return this->x_; }
/** Return a pointer to the object held. */
X* get() const throw() { return this->x_; }
/** Return a pointer to the object held and reset to hold no object.
This transfers ownership to the caller. */
X* release() throw()
{
X* x = this->x_;
this->x_ = 0;
return x;
}
/** Assume ownership of the given object. The object previously
held is deleted. */
void reset(X* p = 0) throw()
{
if (this->x_ != p) {
// Assume object destructor is nothrow.
delete this->x_;
this->x_ = p;
}
}
/** Convert to an auto_ptr holding an object of a compatible type.
This transfers ownership to the returned auto_ptr. */
template <class Y>
operator auto_ptr<Y>() throw()
{
return auto_ptr<Y>(this->release());
}
#if cm_AUTO_PTR_REF
/** Construct from an auto_ptr_ref. This is used when the
constructor argument is a call to a function returning an
auto_ptr. */
auto_ptr(detail::auto_ptr_ref<X> r) throw()
: x_(r.p_)
{
}
/** Assign from an auto_ptr_ref. This is used when a function
returning an auto_ptr is passed on the right-hand-side of an
assignment. */
auto_ptr& operator=(detail::auto_ptr_ref<X> r) throw()
{
this->reset(r.p_);
return *this;
}
/** Convert to an auto_ptr_ref. This is used when a function
returning an auto_ptr is the argument to the constructor of
another auto_ptr. */
template <class Y>
operator detail::auto_ptr_ref<Y>() throw()
{
return detail::auto_ptr_ref<Y>(this->release(), 1);
}
#endif
};
} // namespace cm
// Undo warning suppression.
#if defined(__clang__) && defined(__has_warning)
#if __has_warning("-Wdeprecated")
#pragma clang diagnostic pop
#endif
#endif
#endif

16
Source/cmake.cxx
View File

@ -397,7 +397,7 @@ void cmake::ReadListFile(const std::vector<std::string>& args,
snapshot.GetDirectory().SetCurrentSource(
cmSystemTools::GetCurrentWorkingDirectory());
snapshot.SetDefaultDefinitions();
cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(gg, snapshot));
CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(gg, snapshot));
if (this->GetWorkingMode() != NORMAL_MODE) {
std::string file(cmSystemTools::CollapseFullPath(path));
cmSystemTools::ConvertToUnixSlashes(file);
@ -1743,7 +1743,7 @@ int cmake::CheckBuildSystem()
cm.SetHomeOutputDirectory("");
cm.GetCurrentSnapshot().SetDefaultDefinitions();
cmGlobalGenerator gg(&cm);
cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot()));
CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot()));
if (!mf->ReadListFile(this->CheckBuildSystemArgument.c_str()) ||
cmSystemTools::GetErrorOccuredFlag()) {
if (verbose) {
@ -1764,14 +1764,12 @@ int cmake::CheckBuildSystem()
}
// Create the generator and use it to clear the dependencies.
cmsys::auto_ptr<cmGlobalGenerator> ggd(
this->CreateGlobalGenerator(genName));
CM_AUTO_PTR<cmGlobalGenerator> ggd(this->CreateGlobalGenerator(genName));
if (ggd.get()) {
cm.GetCurrentSnapshot().SetDefaultDefinitions();
cmsys::auto_ptr<cmMakefile> mfd(
CM_AUTO_PTR<cmMakefile> mfd(
new cmMakefile(ggd.get(), cm.GetCurrentSnapshot()));
cmsys::auto_ptr<cmLocalGenerator> lgd(
ggd->CreateLocalGenerator(mfd.get()));
CM_AUTO_PTR<cmLocalGenerator> lgd(ggd->CreateLocalGenerator(mfd.get()));
lgd->ClearDependencies(mfd.get(), verbose);
}
}
@ -1911,7 +1909,7 @@ void cmake::MarkCliAsUsed(const std::string& variable)
void cmake::GenerateGraphViz(const char* fileName) const
{
#ifdef CMAKE_BUILD_WITH_CMAKE
cmsys::auto_ptr<cmGraphVizWriter> gvWriter(
CM_AUTO_PTR<cmGraphVizWriter> gvWriter(
new cmGraphVizWriter(this->GetGlobalGenerator()->GetLocalGenerators()));
std::string settingsFile = this->GetHomeOutputDirectory();
@ -2392,7 +2390,7 @@ int cmake::Build(const std::string& dir, const std::string& target,
std::cerr << "Error: could not find CMAKE_GENERATOR in Cache\n";
return 1;
}
cmsys::auto_ptr<cmGlobalGenerator> gen(
CM_AUTO_PTR<cmGlobalGenerator> gen(
this->CreateGlobalGenerator(cachedGenerator));
if (!gen.get()) {
std::cerr << "Error: could create CMAKE_GENERATOR \"" << cachedGenerator

5
Source/cmcmd.cxx
View File

@ -765,9 +765,8 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args)
cmState::Snapshot snapshot = cm.GetCurrentSnapshot();
snapshot.GetDirectory().SetCurrentBinary(startOutDir);
snapshot.GetDirectory().SetCurrentSource(startDir);
cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(ggd, snapshot));
cmsys::auto_ptr<cmLocalGenerator> lgd(
ggd->CreateLocalGenerator(mf.get()));
CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(ggd, snapshot));
CM_AUTO_PTR<cmLocalGenerator> lgd(ggd->CreateLocalGenerator(mf.get()));
// Actually scan dependencies.
return lgd->UpdateDependencies(depInfo.c_str(), verbose, color) ? 0

1
bootstrap
View File

@ -365,7 +365,6 @@ KWSYS_CXX_SOURCES="\
SystemTools"
KWSYS_FILES="\
auto_ptr.hxx \
Directory.hxx \
Encoding.h \
Encoding.hxx \