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

Avoid using KWSys auto_ptr by adopting it ourselves 

Replace use of cmsys::auto_ptr with a CM_AUTO_PTR macro that maps to
our own implementation adopted from the KWSys auto_ptr implementation.
Later we may be able to map CM_AUTO_PTR to std::auto_ptr on compilers
that do not warn about it.

Automate the client site conversions:

    git grep -l auto_ptr -- Source/ | grep -v Source/kwsys/ | xargs sed -i \
      's|cmsys::auto_ptr|CM_AUTO_PTR|;s|cmsys/auto_ptr.hxx|cm_auto_ptr.hxx|'
This commit is contained in:
Brad King 2016-06-28 10:17:52 -04:00
parent 8d79375818
commit b5ec5b0901
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);

11
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,10 +771,9 @@ public:
void EnforceDirectoryLevelRules() const;
void AddEvaluationFile(
const std::string& inputFile,
cmsys::auto_ptr<cmCompiledGeneratorExpression> outputName,
cmsys::auto_ptr<cmCompiledGeneratorExpression> condition,
void AddEvaluationFile(const std::string& inputFile,
CM_AUTO_PTR<cmCompiledGeneratorExpression> outputName,
CM_AUTO_PTR<cmCompiledGeneratorExpression> condition,
bool inputIsContent);
std::vector<cmGeneratorExpressionEvaluationFile*> GetEvaluationFiles() const;

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 \