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|'

Help/manual/cmake-developer.7.rst

@@ -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
 ------

Source/CMakeLists.txt

@@ -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

Source/CPack/WiX/cmCPackWIXGenerator.cxx

@@ -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;

Source/CPack/cmCPackGenerator.cxx

@@ -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;

Source/CPack/cpack.cxx

@@ -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");

Source/CTest/cmCTestLaunch.cxx

@@ -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()) &&

Source/CTest/cmCTestTestHandler.cxx

@@ -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());
 

Source/CTest/cmCTestUpdateHandler.cxx

@@ -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));

Source/cmCTest.cxx

@@ -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);

Source/cmCryptoHash.cxx

@@ -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);
   }
 }
 

Source/cmCryptoHash.h

@@ -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);
 

Source/cmCustomCommand.cxx

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

Source/cmCustomCommandGenerator.cxx

@@ -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);

Source/cmELF.cxx

@@ -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) {

Source/cmExportFileGenerator.cxx

@@ -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);
 

Source/cmExportLibraryDependenciesCommand.cxx

@@ -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;

Source/cmExportTryCompileFileGenerator.cxx

@@ -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");

Source/cmFileCommand.cxx

@@ -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,

Source/cmFindPackageCommand.cxx

@@ -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;
   }
 };

Source/cmForEachCommand.cxx

@@ -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]);
 

Source/cmGeneratorExpression.cxx

@@ -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 : ""));

Source/cmGeneratorExpression.h

@@ -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
   {

Source/cmGeneratorExpressionEvaluationFile.cxx

@@ -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;

Source/cmGeneratorExpressionEvaluationFile.h

@@ -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;
 };

Source/cmGeneratorExpressionNode.cxx

@@ -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,

Source/cmGeneratorTarget.cxx

@@ -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);

Source/cmGlobalVisualStudio7Generator.cxx

@@ -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))) {

Source/cmGlobalXCodeGenerator.cxx

@@ -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, "

Source/cmGraphVizWriter.cxx

@@ -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;
 

Source/cmIfCommand.cxx

@@ -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;
       }

Source/cmInstallDirectoryGenerator.cxx

@@ -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);
   }

Source/cmInstallFilesGenerator.cxx

@@ -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);
   }

Source/cmInstalledFile.h

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

Source/cmLocalUnixMakefileGenerator3.cxx

@@ -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();

Source/cmLocalVisualStudio7Generator.cxx

@@ -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);

Source/cmLocalVisualStudioGenerator.cxx

@@ -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.

Source/cmLocalVisualStudioGenerator.h

@@ -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

Source/cmMakefile.cxx

@@ -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);

Source/cmMakefile.h

@@ -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()

Source/cmMakefileTargetGenerator.cxx

@@ -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(

Source/cmQtAutoGenerators.cxx

@@ -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);

Source/cmStringCommand.cxx

@@ -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());

Source/cmTarget.h

@@ -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>

Source/cmVariableWatch.cxx

@@ -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;

Source/cmVisualStudio10TargetGenerator.cxx

@@ -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;
 

Source/cmWhileCommand.cxx

@@ -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;
       }

Source/cm_auto_ptr.hxx

@@ -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

Source/cmake.cxx

@@ -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

Source/cmcmd.cxx

@@ -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

bootstrap

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