Refactor internal resource location APIs and initialization

Rename cmSystemTools::FindExecutableDirectory to FindCMakeResources.
Teach it to compute the locations of cmake, ctest, cpack, ccmake, and
cmake-gui executables, and the location of CMAKE_ROOT.  Provide this
information from static cmSystemTools::Get<resource>() methods.
Refactor code that needs these locations to use the new APIs.

Teach FindCMakeResources to use the OS X system API to lookup the
executable location.  When running from the CMake build tree itself,
leave a file in the tree that FindCMakeResources can use to read the
location of the source tree.  This avoids the need to compile the source
tree location into a binary that may be installed and used without the
source tree.

Teach the QtDialog on OS X to create a "cmake-gui" symlink in the build
tree next to "cmake" and the other tools, as is already done in the
install tree for the application bundle.  This ensures a consistent set
of executables are available in one directory.

Source/CMakeLists.txt

@@ -38,6 +38,12 @@ configure_file(
   "${CMake_BINARY_DIR}/Source/CPack/cmCPackConfigure.h"
   )
 
+# Tell CMake executable in the build tree where to find the source tree.
+configure_file(
+  "${CMake_SOURCE_DIR}/Source/CMakeSourceDir.txt.in"
+  "${CMake_BINARY_DIR}/CMakeFiles/CMakeSourceDir.txt" @ONLY
+  )
+
 # add the include path to find the .h
 include_directories(
   "${CMake_BINARY_DIR}/Source"

Source/CMakeSourceDir.txt.in

@@ -0,0 +1 @@
+@CMake_SOURCE_DIR@

Source/CPack/cmCPackGenerator.cxx

@@ -1143,12 +1143,6 @@ int cmCPackGenerator::Initialize(const char* name, cmMakefile* mf)
 {
   this->MakefileMap = mf;
   this->Name = name;
-  if ( !this->SetCMakeRoot() )
-    {
-    cmCPackLogger(cmCPackLog::LOG_ERROR,
-      "Cannot initialize the generator" << std::endl);
-    return 0;
-    }
   // set the running generator name
   this->SetOption("CPACK_GENERATOR", this->Name.c_str());
   // Load the project specific config file
@@ -1204,32 +1198,6 @@ const char* cmCPackGenerator::GetOption(const char* op) const
   return ret;
 }
 
-//----------------------------------------------------------------------
-int cmCPackGenerator::SetCMakeRoot()
-{
-  // use the CMAKE_ROOT from cmake which should have been
-  // found by now
-  const char* root=
-    this->MakefileMap->GetDefinition("CMAKE_ROOT");
-
-  if(root)
-    {
-      this->CMakeRoot = root;
-      cmCPackLogger(cmCPackLog::LOG_DEBUG, "Looking for CMAKE_ROOT: "
-                    << this->CMakeRoot.c_str() << std::endl);
-      this->SetOption("CMAKE_ROOT", this->CMakeRoot.c_str());
-      return 1;
-    }
-  cmCPackLogger(cmCPackLog::LOG_ERROR,
-                "Could not find CMAKE_ROOT !!!"
-                << std::endl
-                << "CMake has most likely not been installed correctly."
-                << std::endl
-                <<"Modules directory not found in"
-                << std::endl);
-  return 0;
-}
-
 //----------------------------------------------------------------------
 int cmCPackGenerator::PackageFiles()
 {

Source/CPack/cmCPackGenerator.h

@@ -105,9 +105,6 @@ public:
   bool IsSet(const char* name) const;
   bool IsOn(const char* name) const;
 
-  //! Set all the variables
-  int SetCMakeRoot();
-
   //! Set the logger
   void SetLogger(cmCPackLog* log) { this->Logger = log; }
 
@@ -285,10 +282,6 @@ protected:
    */
   std::vector<std::string> files;
 
-  std::string CPackSelf;
-  std::string CMakeSelf;
-  std::string CMakeRoot;
-
   std::map<std::string, cmCPackInstallationType> InstallationTypes;
   /**
    * The set of components.

Source/CPack/cpack.cxx

@@ -99,7 +99,7 @@ int cpackDefinitionArgument(const char* argument, const char* cValue,
 // this is CPack.
 int main (int argc, char *argv[])
 {
-  cmSystemTools::FindExecutableDirectory(argv[0]);
+  cmSystemTools::FindCMakeResources(argv[0]);
   cmCPackLog log;
 
   log.SetErrorPrefix("CPack Error: ");
@@ -228,7 +228,6 @@ int main (int argc, char *argv[])
 
   // This part is used for cpack documentation lookup as well.
   cminst.AddCMakePaths();
-  doc.SetCMakeRoot(cminst.GetCacheDefinition("CMAKE_ROOT"));
 
   if ( parsed && !help )
     {

Source/CTest/cmCTestBuildAndTestHandler.cxx

@@ -59,7 +59,7 @@ int cmCTestBuildAndTestHandler::RunCMake(std::string* outstring,
 {
   unsigned int k;
   std::vector<std::string> args;
-  args.push_back(this->CTest->GetCMakeExecutable());
+  args.push_back(cmSystemTools::GetCMakeCommand());
   args.push_back(this->SourceDir);
   if(this->BuildGenerator.size())
     {

Source/CTest/cmCTestConfigureCommand.cxx

@@ -86,7 +86,7 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
         }
 
       std::string cmakeConfigureCommand = "\"";
-      cmakeConfigureCommand += this->CTest->GetCMakeExecutable();
+      cmakeConfigureCommand += cmSystemTools::GetCMakeCommand();
       cmakeConfigureCommand += "\"";
 
       std::vector<std::string>::const_iterator it;

Source/CTest/cmCTestScriptHandler.cxx

@@ -222,13 +222,13 @@ int cmCTestScriptHandler::ExecuteScript(const std::string& total_script_arg)
   // execute the script passing in the arguments to the script as well as the
   // arguments from this invocation of cmake
   std::vector<const char*> argv;
-  argv.push_back(this->CTest->GetCTestExecutable());
+  argv.push_back(cmSystemTools::GetCTestCommand().c_str());
   argv.push_back("-SR");
   argv.push_back(total_script_arg.c_str());
 
   cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
              "Executable for CTest is: " <<
-             this->CTest->GetCTestExecutable() << "\n");
+             cmSystemTools::GetCTestCommand() << "\n");
 
   // now pass through all the other arguments
   std::vector<cmStdString> &initArgs =
@@ -397,9 +397,9 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg)
   this->Makefile->AddDefinition("CTEST_SCRIPT_NAME",
                             cmSystemTools::GetFilenameName(script).c_str());
   this->Makefile->AddDefinition("CTEST_EXECUTABLE_NAME",
-                            this->CTest->GetCTestExecutable());
+                                cmSystemTools::GetCTestCommand().c_str());
   this->Makefile->AddDefinition("CMAKE_EXECUTABLE_NAME",
-                            this->CTest->GetCMakeExecutable());
+                                cmSystemTools::GetCMakeCommand().c_str());
   this->Makefile->AddDefinition("CTEST_RUN_CURRENT_SCRIPT", true);
   this->UpdateElapsedTime();
 

Source/CursesDialog/ccmake.cxx

@@ -80,14 +80,13 @@ void CMakeErrorHandler(const char* message, const char* title, bool&, void* clie
 
 int main(int argc, char** argv)
 {
-  cmSystemTools::FindExecutableDirectory(argv[0]);
+  cmSystemTools::FindCMakeResources(argv[0]);
   cmDocumentation doc;
   doc.addCMakeStandardDocSections();
   if(doc.CheckOptions(argc, argv))
     {
     cmake hcm;
     hcm.AddCMakePaths();
-    doc.SetCMakeRoot(hcm.GetCacheDefinition("CMAKE_ROOT"));
     std::vector<cmDocumentationEntry> generators;
     hcm.GetGeneratorDocumentation(generators);
     doc.SetName("ccmake");

Source/CursesDialog/cmCursesMainForm.cxx

@@ -43,14 +43,14 @@ cmCursesMainForm::cmCursesMainForm(std::vector<std::string> const& args,
   this->HelpMessage.push_back("");
   this->HelpMessage.push_back(s_ConstHelpMessage);
   this->CMakeInstance = new cmake;
-  this->CMakeInstance->SetCMakeEditCommand("ccmake");
+  this->CMakeInstance->SetCMakeEditCommand(
+    cmSystemTools::GetCMakeCursesCommand());
 
   // create the arguments for the cmake object
   std::string whereCMake = cmSystemTools::GetProgramPath(this->Args[0].c_str());
   whereCMake += "/cmake";
   this->Args[0] = whereCMake;
   this->CMakeInstance->SetArgs(this->Args);
-  this->CMakeInstance->SetCMakeCommand(whereCMake.c_str());
   this->SearchString = "";
   this->OldSearchString = "";
   this->SearchMode = false;

Source/QtDialog/CMakeLists.txt

@@ -118,6 +118,13 @@ if(APPLE)
     # TBD: MACOSX_BUNDLE_BUNDLE_VERSION "${CMAKE_BUNDLE_VERSION}"
     MACOSX_BUNDLE_COPYRIGHT "Copyright 2000-2013 Kitware, Inc."
     )
+
+  # Create a symlink in the build tree to provide a "cmake-gui" next
+  # to the "cmake" executable that refers to the application bundle.
+  add_custom_command(TARGET cmake-gui POST_BUILD
+    COMMAND ln -sf ${CMAKE_BUNDLE_NAME}.app/Contents/MacOS/${CMAKE_BUNDLE_NAME}
+                   $<TARGET_FILE_DIR:cmake>/cmake-gui
+    )
 endif()
 set(CMAKE_INSTALL_DESTINATION_ARGS
   BUNDLE DESTINATION "${CMAKE_BUNDLE_LOCATION}")

Source/QtDialog/CMakeSetup.cxx

@@ -48,7 +48,7 @@ static const char * cmDocumentationOptions[][2] =
 
 int main(int argc, char** argv)
 {
-  cmSystemTools::FindExecutableDirectory(argv[0]);
+  cmSystemTools::FindCMakeResources(argv[0]);
   // check docs first so that X is not need to get docs
   // do docs, if args were given
   cmDocumentation doc;
@@ -58,7 +58,6 @@ int main(int argc, char** argv)
     // Construct and print requested documentation.
     cmake hcm;
     hcm.AddCMakePaths();
-    doc.SetCMakeRoot(hcm.GetCacheDefinition("CMAKE_ROOT"));
 
     std::vector<cmDocumentationEntry> generators;
     hcm.GetGeneratorDocumentation(generators);

Source/QtDialog/QCMake.cxx

@@ -33,34 +33,13 @@ QCMake::QCMake(QObject* p)
   qRegisterMetaType<QCMakeProperty>();
   qRegisterMetaType<QCMakePropertyList>();
 
-  QDir execDir(QCoreApplication::applicationDirPath());
-
-#if defined(Q_OS_MAC)
-  if(execDir.exists("../bin/cmake"))
-    {
-    execDir.cd("../bin");
-    }
-  else
-    {
-    execDir.cd("../../../");  // path to cmake in build directory (need to fix for deployment)
-    }
-#endif
-
-  QString cmakeCommand = QString("cmake")+QString::fromLocal8Bit(cmSystemTools::GetExecutableExtension());
-  cmakeCommand = execDir.filePath(cmakeCommand);
-
   cmSystemTools::DisableRunCommandOutput();
   cmSystemTools::SetRunCommandHideConsole(true);
   cmSystemTools::SetErrorCallback(QCMake::errorCallback, this);
-  cmSystemTools::FindExecutableDirectory(cmakeCommand.toLocal8Bit().data());
 
   this->CMakeInstance = new cmake;
-  this->CMakeInstance->SetCMakeCommand(cmakeCommand.toLocal8Bit().data());
-#if defined(Q_OS_MAC)
-  this->CMakeInstance->SetCMakeEditCommand("cmake-gui.app/Contents/MacOS/cmake-gui");
-#else
-  this->CMakeInstance->SetCMakeEditCommand("cmake-gui");
-#endif
+  this->CMakeInstance->SetCMakeEditCommand(
+    cmSystemTools::GetCMakeGUICommand());
   this->CMakeInstance->SetProgressCallback(QCMake::progressCallback, this);
 
   cmSystemTools::SetInterruptCallback(QCMake::interruptCallback, this);

Source/cmCTest.cxx

@@ -1298,7 +1298,8 @@ int cmCTest::RunTest(std::vector<const char*> argv,
     }
   cmCTestLog(this, HANDLER_VERBOSE_OUTPUT,
              "Test timeout computed to be: " << timeout << "\n");
-  if(cmSystemTools::SameFile(argv[0], this->CTestSelf.c_str()) &&
+  if(cmSystemTools::SameFile(
+       argv[0], cmSystemTools::GetCTestCommand().c_str()) &&
      !this->ForceNewCTestProcess)
     {
     cmCTest inst;
@@ -2257,7 +2258,6 @@ bool cmCTest::AddVariableDefinition(const std::string &arg)
 // the main entry point of ctest, called from main
 int cmCTest::Run(std::vector<std::string> &args, std::string* output)
 {
-  this->FindRunningCMake();
   const char* ctestExec = "ctest";
   bool cmakeAndTest = false;
   bool executeTests = true;
@@ -2497,29 +2497,6 @@ int cmCTest::Run(std::vector<std::string> &args, std::string* output)
   return 1;
 }
 
-//----------------------------------------------------------------------
-void cmCTest::FindRunningCMake()
-{
-  // Find our own executable.
-  this->CTestSelf = cmSystemTools::GetExecutableDirectory();
-  this->CTestSelf += "/ctest";
-  this->CTestSelf += cmSystemTools::GetExecutableExtension();
-  if(!cmSystemTools::FileExists(this->CTestSelf.c_str()))
-    {
-    cmSystemTools::Error("CTest executable cannot be found at ",
-                         this->CTestSelf.c_str());
-    }
-
-  this->CMakeSelf = cmSystemTools::GetExecutableDirectory();
-  this->CMakeSelf += "/cmake";
-  this->CMakeSelf += cmSystemTools::GetExecutableExtension();
-  if(!cmSystemTools::FileExists(this->CMakeSelf.c_str()))
-    {
-    cmSystemTools::Error("CMake executable cannot be found at ",
-                         this->CMakeSelf.c_str());
-    }
-}
-
 //----------------------------------------------------------------------
 void cmCTest::SetNotesFiles(const char* notes)
 {

Source/cmCTest.h

@@ -287,10 +287,6 @@ public:
   //source directory, it will become /.../relative/path/to/file
   std::string GetShortPathToFile(const char* fname);
 
-  //! Get the path to CTest
-  const char* GetCTestExecutable() { return this->CTestSelf.c_str(); }
-  const char* GetCMakeExecutable() { return this->CMakeSelf.c_str(); }
-
   enum {
     EXPERIMENTAL,
     NIGHTLY,
@@ -490,8 +486,6 @@ private:
   int                     CompatibilityMode;
 
   // information for the --build-and-test options
-  std::string              CMakeSelf;
-  std::string              CTestSelf;
   std::string              BinaryDir;
 
   std::string              NotesFiles;
@@ -546,9 +540,6 @@ private:
   int GenerateCTestNotesOutput(std::ostream& os,
     const VectorOfStrings& files);
 
-  ///! Find the running cmake
-  void FindRunningCMake();
-
   //! Check if the argument is the one specified
   bool CheckArgument(const std::string& arg, const char* varg1,
     const char* varg2 = 0);

Source/cmConfigure.cmake.h.in

@@ -16,6 +16,4 @@
 #cmakedefine HAVE_ENVIRON_NOT_REQUIRE_PROTOTYPE
 #cmakedefine HAVE_UNSETENV
 #cmakedefine CMAKE_USE_ELF_PARSER
-#define  CMAKE_ROOT_DIR "${CMake_SOURCE_DIR}"
-#define  CMAKE_BUILD_DIR "${CMake_BINARY_DIR}"
 #define CMAKE_DATA_DIR "/@CMAKE_DATA_DIR@"

Source/cmDocumentation.cxx

@@ -605,7 +605,8 @@ void cmDocumentation::GlobHelp(std::vector<std::string>& files,
                                std::string const& pattern)
 {
   cmsys::Glob gl;
-  std::string findExpr = this->CMakeRoot + "/Help/" + pattern + ".rst";
+  std::string findExpr =
+    cmSystemTools::GetCMakeRoot() + "/Help/" + pattern + ".rst";
   if(gl.FindFiles(findExpr))
     {
     files = gl.GetFiles();
@@ -649,7 +650,7 @@ bool cmDocumentation::PrintFiles(std::ostream& os,
   std::vector<std::string> files;
   this->GlobHelp(files, pattern);
   std::sort(files.begin(), files.end());
-  cmRST r(os, this->CMakeRoot + "/Help");
+  cmRST r(os, cmSystemTools::GetCMakeRoot() + "/Help");
   for (std::vector<std::string>::const_iterator i = files.begin();
        i != files.end(); ++i)
     {

Source/cmDocumentation.h

@@ -83,9 +83,6 @@ public:
   void AppendSection(const char *sectionName,
                      cmDocumentationEntry &docs);
 
-  /** Set cmake root so we can find installed files */
-  void SetCMakeRoot(const char* root) { this->CMakeRoot = root? root:"";}
-
   /** Add common (to all tools) documentation section(s) */
   void addCommonStandardDocSections();
 
@@ -127,7 +124,6 @@ private:
   std::string NameString;
   std::map<std::string,cmDocumentationSection*> AllSections;
 
-  std::string CMakeRoot;
   std::string CurrentArgument;
 
   struct RequestedHelpItem

Source/cmGlobalGenerator.cxx

@@ -2068,7 +2068,7 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets)
   cmCustomCommandLines cpackCommandLines;
   std::vector<std::string> depends;
   cmCustomCommandLine singleLine;
-  singleLine.push_back(this->GetCMakeInstance()->GetCPackCommand());
+  singleLine.push_back(cmSystemTools::GetCPackCommand());
   if ( cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.' )
     {
     singleLine.push_back("-C");
@@ -2109,7 +2109,7 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets)
                             cpackCommandLines.end());
     singleLine.erase(singleLine.begin(), singleLine.end());
     depends.erase(depends.begin(), depends.end());
-    singleLine.push_back(this->GetCMakeInstance()->GetCPackCommand());
+    singleLine.push_back(cmSystemTools::GetCPackCommand());
     singleLine.push_back("--config");
     configFile = mf->GetStartOutputDirectory();;
     configFile += "/CPackSourceConfig.cmake";
@@ -2135,7 +2135,7 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets)
                             cpackCommandLines.end());
     singleLine.erase(singleLine.begin(), singleLine.end());
     depends.erase(depends.begin(), depends.end());
-    singleLine.push_back(this->GetCMakeInstance()->GetCTestCommand());
+    singleLine.push_back(cmSystemTools::GetCTestCommand());
     singleLine.push_back("--force-new-ctest-process");
     if(cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.')
       {

Source/cmMakefile.cxx

@@ -3072,7 +3072,6 @@ int cmMakefile::TryCompile(const char *srcdir, const char *bindir,
   cm.SetHomeOutputDirectory(bindir);
   cm.SetStartDirectory(srcdir);
   cm.SetStartOutputDirectory(bindir);
-  cm.SetCMakeCommand(cmakeCommand.c_str());
   cm.SetGeneratorToolset(this->GetCMakeInstance()->GetGeneratorToolset());
   cm.LoadCache();
   if(!gg->IsMultiConfig())

Source/cmSystemTools.cxx

@@ -43,6 +43,10 @@
 # include <sys/wait.h>
 #endif
 
+#if defined(__APPLE__)
+# include <mach-o/dyld.h>
+#endif
+
 #include <sys/stat.h>
 
 #if defined(_WIN32) && \
@@ -2011,16 +2015,59 @@ unsigned int cmSystemTools::RandomSeed()
 }
 
 //----------------------------------------------------------------------------
-static std::string cmSystemToolsExecutableDirectory;
-void cmSystemTools::FindExecutableDirectory(const char* argv0)
-{
+static std::string cmSystemToolsCMakeCommand;
+static std::string cmSystemToolsCTestCommand;
+static std::string cmSystemToolsCPackCommand;
+static std::string cmSystemToolsCMakeCursesCommand;
+static std::string cmSystemToolsCMakeGUICommand;
+static std::string cmSystemToolsCMakeRoot;
+void cmSystemTools::FindCMakeResources(const char* argv0)
+{
+  std::string exe_dir;
 #if defined(_WIN32) && !defined(__CYGWIN__)
   (void)argv0; // ignore this on windows
   char modulepath[_MAX_PATH];
   ::GetModuleFileName(NULL, modulepath, sizeof(modulepath));
-  cmSystemToolsExecutableDirectory =
-    cmSystemTools::GetFilenamePath(modulepath);
-  return;
+  exe_dir = cmSystemTools::GetFilenamePath(modulepath);
+#elif defined(__APPLE__)
+  (void)argv0; // ignore this on OS X
+# define CM_EXE_PATH_LOCAL_SIZE 16384
+  char exe_path_local[CM_EXE_PATH_LOCAL_SIZE];
+# if defined(MAC_OS_X_VERSION_10_3) && !defined(MAC_OS_X_VERSION_10_4)
+  unsigned long exe_path_size = CM_EXE_PATH_LOCAL_SIZE;
+# else
+  uint32_t exe_path_size = CM_EXE_PATH_LOCAL_SIZE;
+# endif
+# undef CM_EXE_PATH_LOCAL_SIZE
+  char* exe_path = exe_path_local;
+  if(_NSGetExecutablePath(exe_path, &exe_path_size) < 0)
+    {
+    exe_path = (char*)malloc(exe_path_size);
+    _NSGetExecutablePath(exe_path, &exe_path_size);
+    }
+  exe_dir =
+    cmSystemTools::GetFilenamePath(
+      cmSystemTools::GetRealPath(exe_path));
+  if(exe_path != exe_path_local)
+    {
+    free(exe_path);
+    }
+  if(cmSystemTools::GetFilenameName(exe_dir) == "MacOS")
+    {
+    // The executable is inside an application bundle.
+    // Look for ../bin (install tree) and then fall back to
+    // ../../../bin (build tree).
+    exe_dir = cmSystemTools::GetFilenamePath(exe_dir);
+    if(cmSystemTools::FileExists((exe_dir+"/bin/cmake").c_str()))
+      {
+      exe_dir += "/bin";
+      }
+    else
+      {
+      exe_dir = cmSystemTools::GetFilenamePath(exe_dir);
+      exe_dir = cmSystemTools::GetFilenamePath(exe_dir);
+      }
+    }
 #else
   std::string errorMsg;
   std::string exe;
@@ -2028,7 +2075,7 @@ void cmSystemTools::FindExecutableDirectory(const char* argv0)
     {
     // remove symlinks
     exe = cmSystemTools::GetRealPath(exe.c_str());
-    cmSystemToolsExecutableDirectory =
+    exe_dir =
       cmSystemTools::GetFilenamePath(exe.c_str());
     }
   else
@@ -2036,12 +2083,99 @@ void cmSystemTools::FindExecutableDirectory(const char* argv0)
     // ???
     }
 #endif
+  cmSystemToolsCMakeCommand = exe_dir;
+  cmSystemToolsCMakeCommand += "/cmake";
+  cmSystemToolsCMakeCommand += cmSystemTools::GetExecutableExtension();
+  cmSystemToolsCTestCommand = exe_dir;
+  cmSystemToolsCTestCommand += "/ctest";
+  cmSystemToolsCTestCommand += cmSystemTools::GetExecutableExtension();
+  cmSystemToolsCPackCommand = exe_dir;
+  cmSystemToolsCPackCommand += "/cpack";
+  cmSystemToolsCPackCommand += cmSystemTools::GetExecutableExtension();
+  cmSystemToolsCMakeGUICommand = exe_dir;
+  cmSystemToolsCMakeGUICommand += "/cmake-gui";
+  cmSystemToolsCMakeGUICommand += cmSystemTools::GetExecutableExtension();
+  if(!cmSystemTools::FileExists(cmSystemToolsCMakeGUICommand.c_str()))
+    {
+    cmSystemToolsCMakeGUICommand = "";
+    }
+  cmSystemToolsCMakeCursesCommand = exe_dir;
+  cmSystemToolsCMakeCursesCommand += "/ccmake";
+  cmSystemToolsCMakeCursesCommand += cmSystemTools::GetExecutableExtension();
+  if(!cmSystemTools::FileExists(cmSystemToolsCMakeCursesCommand.c_str()))
+    {
+    cmSystemToolsCMakeCursesCommand = "";
+    }
+
+#ifdef CMAKE_BUILD_WITH_CMAKE
+  // Install tree has "<prefix>/bin/cmake" and "<prefix><CMAKE_DATA_DIR>".
+  std::string dir = cmSystemTools::GetFilenamePath(exe_dir);
+  cmSystemToolsCMakeRoot = dir + CMAKE_DATA_DIR;
+  if(!cmSystemTools::FileExists(
+       (cmSystemToolsCMakeRoot+"/Modules/CMake.cmake").c_str()))
+    {
+    // Build tree has "<build>/bin[/<config>]/cmake" and
+    // "<build>/CMakeFiles/CMakeSourceDir.txt".
+    std::string src_dir_txt = dir + "/CMakeFiles/CMakeSourceDir.txt";
+    std::ifstream fin(src_dir_txt.c_str());
+    std::string src_dir;
+    if(fin && cmSystemTools::GetLineFromStream(fin, src_dir) &&
+       cmSystemTools::FileIsDirectory(src_dir.c_str()))
+      {
+      cmSystemToolsCMakeRoot = src_dir;
+      }
+    else
+      {
+      dir = cmSystemTools::GetFilenamePath(dir);
+      src_dir_txt = dir + "/CMakeFiles/CMakeSourceDir.txt";
+      std::ifstream fin2(src_dir_txt.c_str());
+      if(fin2 && cmSystemTools::GetLineFromStream(fin2, src_dir) &&
+         cmSystemTools::FileIsDirectory(src_dir.c_str()))
+        {
+        cmSystemToolsCMakeRoot = src_dir;
+        }
+      }
+    }
+#else
+  // Bootstrap build knows its source.
+  cmSystemToolsCMakeRoot = CMAKE_ROOT_DIR;
+#endif
+}
+
+//----------------------------------------------------------------------------
+std::string const& cmSystemTools::GetCMakeCommand()
+{
+  return cmSystemToolsCMakeCommand;
+}
+
+//----------------------------------------------------------------------------
+std::string const& cmSystemTools::GetCTestCommand()
+{
+  return cmSystemToolsCTestCommand;
+}
+
+//----------------------------------------------------------------------------
+std::string const& cmSystemTools::GetCPackCommand()
+{
+  return cmSystemToolsCPackCommand;
+}
+
+//----------------------------------------------------------------------------
+std::string const& cmSystemTools::GetCMakeCursesCommand()
+{
+  return cmSystemToolsCMakeCursesCommand;
+}
+
+//----------------------------------------------------------------------------
+std::string const& cmSystemTools::GetCMakeGUICommand()
+{
+  return cmSystemToolsCMakeGUICommand;
 }
 
 //----------------------------------------------------------------------------
-const char* cmSystemTools::GetExecutableDirectory()
+std::string const& cmSystemTools::GetCMakeRoot()
 {
-  return cmSystemToolsExecutableDirectory.c_str();
+  return cmSystemToolsCMakeRoot;
 }
 
 //----------------------------------------------------------------------------

Source/cmSystemTools.h

@@ -406,13 +406,16 @@ public:
   /** Random seed generation.  */
   static unsigned int RandomSeed();
 
-  /** Find the directory containing the running executable.  Save it
-   in a global location to be queried by GetExecutableDirectory
-   later.  */
-  static void FindExecutableDirectory(const char* argv0);
-
-  /** Get the directory containing the currently running executable.  */
-  static const char* GetExecutableDirectory();
+  /** Find the directory containing CMake executables.  */
+  static void FindCMakeResources(const char* argv0);
+
+  /** Get the CMake resource paths, after FindCMakeResources.  */
+  static std::string const& GetCTestCommand();
+  static std::string const& GetCPackCommand();
+  static std::string const& GetCMakeCommand();
+  static std::string const& GetCMakeGUICommand();
+  static std::string const& GetCMakeCursesCommand();
+  static std::string const& GetCMakeRoot();
 
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   /** Echo a message in color using KWSys's Terminal cprintf.  */

Source/cmake.cxx

@@ -932,34 +932,18 @@ void cmake::SetDirectoriesFromFile(const char* arg)
 // cache
 int cmake::AddCMakePaths()
 {
-  // Find the cmake executable
-  std::string cMakeSelf = cmSystemTools::GetExecutableDirectory();
-  cMakeSelf = cmSystemTools::GetRealPath(cMakeSelf.c_str());
-  cMakeSelf += "/cmake";
-  cMakeSelf += cmSystemTools::GetExecutableExtension();
-#ifdef __APPLE__
-  // on the apple this might be the gui bundle
-  if(!cmSystemTools::FileExists(cMakeSelf.c_str()))
-    {
-    cMakeSelf = cmSystemTools::GetExecutableDirectory();
-    cMakeSelf = cmSystemTools::GetRealPath(cMakeSelf.c_str());
-    cMakeSelf += "../../../..";
-    cMakeSelf = cmSystemTools::GetRealPath(cMakeSelf.c_str());
-    cMakeSelf = cmSystemTools::CollapseFullPath(cMakeSelf.c_str());
-    cMakeSelf += "/cmake";
-    std::cerr << cMakeSelf.c_str() << "\n";
-    }
-#endif
-  if(!cmSystemTools::FileExists(cMakeSelf.c_str()))
-    {
-    cmSystemTools::Error("CMake executable cannot be found at ",
-                         cMakeSelf.c_str());
-    return 0;
-    }
   // Save the value in the cache
   this->CacheManager->AddCacheEntry
-    ("CMAKE_COMMAND",cMakeSelf.c_str(), "Path to CMake executable.",
-     cmCacheManager::INTERNAL);
+    ("CMAKE_COMMAND", cmSystemTools::GetCMakeCommand().c_str(),
+     "Path to CMake executable.", cmCacheManager::INTERNAL);
+#ifdef CMAKE_BUILD_WITH_CMAKE
+  this->CacheManager->AddCacheEntry
+    ("CMAKE_CTEST_COMMAND", cmSystemTools::GetCTestCommand().c_str(),
+     "Path to ctest program executable.", cmCacheManager::INTERNAL);
+  this->CacheManager->AddCacheEntry
+    ("CMAKE_CPACK_COMMAND", cmSystemTools::GetCPackCommand().c_str(),
+     "Path to cpack program executable.", cmCacheManager::INTERNAL);
+#endif
   // if the edit command is not yet in the cache,
   // or if CMakeEditCommand has been set on this object,
   // then set the CMAKE_EDIT_COMMAND in the cache
@@ -972,20 +956,17 @@ int cmake::AddCMakePaths()
     std::string editCacheCommand;
     if(!this->CMakeEditCommand.empty())
       {
-      editCacheCommand = cmSystemTools::GetFilenamePath(cMakeSelf)
-        + std::string("/")
-        + this->CMakeEditCommand
-        + cmSystemTools::GetFilenameExtension(cMakeSelf);
+      editCacheCommand = this->CMakeEditCommand;
       }
-    if( !cmSystemTools::FileExists(editCacheCommand.c_str()))
+    if(!cmSystemTools::FileExists(editCacheCommand.c_str()) &&
+       !cmSystemTools::GetCMakeCursesCommand().empty())
       {
-      editCacheCommand = cmSystemTools::GetFilenamePath(cMakeSelf) +
-        "/ccmake" + cmSystemTools::GetFilenameExtension(cMakeSelf);
+      editCacheCommand = cmSystemTools::GetCMakeCursesCommand();
       }
-    if( !cmSystemTools::FileExists(editCacheCommand.c_str()))
+    if(!cmSystemTools::FileExists(editCacheCommand.c_str()) &&
+       !cmSystemTools::GetCMakeGUICommand().empty())
       {
-      editCacheCommand = cmSystemTools::GetFilenamePath(cMakeSelf) +
-        "/cmake-gui" + cmSystemTools::GetFilenameExtension(cMakeSelf);
+      editCacheCommand = cmSystemTools::GetCMakeGUICommand();
       }
     if(cmSystemTools::FileExists(editCacheCommand.c_str()))
       {
@@ -994,84 +975,19 @@ int cmake::AddCMakePaths()
          "Path to cache edit program executable.", cmCacheManager::INTERNAL);
       }
     }
-  std::string ctestCommand = cmSystemTools::GetFilenamePath(cMakeSelf) +
-    "/ctest" + cmSystemTools::GetFilenameExtension(cMakeSelf);
-  if(cmSystemTools::FileExists(ctestCommand.c_str()))
-    {
-    this->CacheManager->AddCacheEntry
-      ("CMAKE_CTEST_COMMAND", ctestCommand.c_str(),
-       "Path to ctest program executable.", cmCacheManager::INTERNAL);
-    }
-  std::string cpackCommand = cmSystemTools::GetFilenamePath(cMakeSelf) +
-    "/cpack" + cmSystemTools::GetFilenameExtension(cMakeSelf);
-  if(cmSystemTools::FileExists(cpackCommand.c_str()))
-    {
-    this->CacheManager->AddCacheEntry
-      ("CMAKE_CPACK_COMMAND", cpackCommand.c_str(),
-       "Path to cpack program executable.", cmCacheManager::INTERNAL);
-    }
 
-  // do CMAKE_ROOT, look for the environment variable first
-  std::string cMakeRoot;
-  std::string modules;
-  if (getenv("CMAKE_ROOT"))
-    {
-    cMakeRoot = getenv("CMAKE_ROOT");
-    modules = cMakeRoot + "/Modules/CMake.cmake";
-    }
-  if(!cmSystemTools::FileExists(modules.c_str()))
-    {
-    // next try exe/..
-    cMakeRoot = cmSystemTools::GetRealPath(cMakeSelf.c_str());
-    cMakeRoot = cmSystemTools::GetProgramPath(cMakeRoot.c_str());
-    std::string::size_type slashPos = cMakeRoot.rfind("/");
-    if(slashPos != std::string::npos)
-      {
-      cMakeRoot = cMakeRoot.substr(0, slashPos);
-      }
-    // is there no Modules directory there?
-    modules = cMakeRoot + "/Modules/CMake.cmake";
-    }
-
-  if (!cmSystemTools::FileExists(modules.c_str()))
-    {
-    // try exe/../share/cmake
-    cMakeRoot += CMAKE_DATA_DIR;
-    modules = cMakeRoot + "/Modules/CMake.cmake";
-    }
-#ifdef CMAKE_ROOT_DIR
-  if (!cmSystemTools::FileExists(modules.c_str()))
-    {
-    // try compiled in root directory
-    cMakeRoot = CMAKE_ROOT_DIR;
-    modules = cMakeRoot + "/Modules/CMake.cmake";
-    }
-#endif
-  if (!cmSystemTools::FileExists(modules.c_str()))
-    {
-    // try
-    cMakeRoot  = cmSystemTools::GetProgramPath(cMakeSelf.c_str());
-    cMakeRoot += CMAKE_DATA_DIR;
-    modules = cMakeRoot +  "/Modules/CMake.cmake";
-    }
-  if(!cmSystemTools::FileExists(modules.c_str()))
-    {
-    // next try exe
-    cMakeRoot  = cmSystemTools::GetProgramPath(cMakeSelf.c_str());
-    // is there no Modules directory there?
-    modules = cMakeRoot + "/Modules/CMake.cmake";
-    }
-  if (!cmSystemTools::FileExists(modules.c_str()))
+  if(!cmSystemTools::FileExists(
+       (cmSystemTools::GetCMakeRoot()+"/Modules/CMake.cmake").c_str()))
     {
     // couldn't find modules
     cmSystemTools::Error("Could not find CMAKE_ROOT !!!\n"
       "CMake has most likely not been installed correctly.\n"
       "Modules directory not found in\n",
-      cMakeRoot.c_str());
+      cmSystemTools::GetCMakeRoot().c_str());
     return 0;
     }
   this->CacheManager->AddCacheEntry
-    ("CMAKE_ROOT", cMakeRoot.c_str(),
+    ("CMAKE_ROOT", cmSystemTools::GetCMakeRoot().c_str(),
      "Path to CMake installation.", cmCacheManager::INTERNAL);
 
   return 1;
@@ -1705,9 +1621,6 @@ int cmake::Run(const std::vector<std::string>& args, bool noconfigure)
     return 0;
     }
 
-  // set the cmake command
-  this->CMakeCommand = args[0];
-
   if ( this->GetWorkingMode() == NORMAL_MODE )
     {
     // load the cache
@@ -1925,14 +1838,6 @@ int cmake::LoadCache()
       }
     }
 
-  if (this->CMakeCommand.size() < 2)
-    {
-    cmSystemTools::Error(
-      "cmake command was not specified prior to loading the cache in "
-      "cmake.cxx");
-    return -1;
-    }
-
   // setup CMAKE_ROOT and CMAKE_COMMAND
   if(!this->AddCMakePaths())
     {
@@ -2238,82 +2143,6 @@ inline std::string removeQuotes(const std::string& s)
   return s;
 }
 
-std::string cmake::FindCMakeProgram(const char* name) const
-{
-  std::string path;
-  if ((name) && (*name))
-    {
-    const cmMakefile* mf
-        = this->GetGlobalGenerator()->GetLocalGenerators()[0]->GetMakefile();
-#ifdef CMAKE_BUILD_WITH_CMAKE
-    path = mf->GetRequiredDefinition("CMAKE_COMMAND");
-    path = removeQuotes(path);
-    path = cmSystemTools::GetFilenamePath(path.c_str());
-    path += "/";
-    path += name;
-    path += cmSystemTools::GetExecutableExtension();
-    if(!cmSystemTools::FileExists(path.c_str()))
-    {
-      path = mf->GetRequiredDefinition("CMAKE_COMMAND");
-      path = cmSystemTools::GetFilenamePath(path.c_str());
-      path += "/Debug/";
-      path += name;
-      path += cmSystemTools::GetExecutableExtension();
-    }
-    if(!cmSystemTools::FileExists(path.c_str()))
-    {
-      path = mf->GetRequiredDefinition("CMAKE_COMMAND");
-      path = cmSystemTools::GetFilenamePath(path.c_str());
-      path += "/Release/";
-      path += name;
-      path += cmSystemTools::GetExecutableExtension();
-    }
-#else
-    // Only for bootstrap
-    path += mf->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
-    path += "/";
-    path += name;
-    path += cmSystemTools::GetExecutableExtension();
-#endif
-    }
-  return path;
-}
-
-const char* cmake::GetCTestCommand()
-{
-  if ( this->CTestCommand.empty() )
-    {
-    this->CTestCommand = this->FindCMakeProgram("ctest");
-    }
-  if ( this->CTestCommand.empty() )
-    {
-    cmSystemTools::Error("Cannot find the CTest executable");
-    this->CTestCommand = "CTEST-COMMAND-NOT-FOUND";
-    }
-  return this->CTestCommand.c_str();
-}
-
-const char* cmake::GetCPackCommand()
-{
-  if ( this->CPackCommand.empty() )
-    {
-    this->CPackCommand = this->FindCMakeProgram("cpack");
-    }
-  if ( this->CPackCommand.empty() )
-    {
-    cmSystemTools::Error("Cannot find the CPack executable");
-    this->CPackCommand = "CPACK-COMMAND-NOT-FOUND";
-    }
-    return this->CPackCommand.c_str();
-}
-
-
-const char* cmake::GetCMakeCommand()
-{
-  return this->CMakeCommand.c_str();
-}
-
-
 void cmake::MarkCliAsUsed(const std::string& variable)
 {
   this->UsedCliVariables[variable] = true;

Source/cmake.h

@@ -200,9 +200,6 @@ class cmake
   ///! get the cmCachemManager used by this invocation of cmake
   cmCacheManager *GetCacheManager() { return this->CacheManager; }
 
-  ///! set the cmake command this instance of cmake should use
-  void SetCMakeCommand(const char* cmd) { this->CMakeCommand = cmd; }
-
   /**
    * Given a variable name, return its value (as a string).
    */
@@ -301,13 +298,6 @@ class cmake
    */
   cmFileTimeComparison* GetFileComparison() { return this->FileComparison; }
 
-  /**
-   * Get the path to ctest
-   */
-  const char* GetCTestCommand();
-  const char* GetCPackCommand();
-  const char* GetCMakeCommand();
-
   // Do we want debug output during the cmake run.
   bool GetDebugOutput() { return this->DebugOutput; }
   void SetDebugOutputOn(bool b) { this->DebugOutput = b;}
@@ -344,7 +334,7 @@ class cmake
       debugging configurations.*/
   std::vector<std::string> const& GetDebugConfigs();
 
-  void SetCMakeEditCommand(const char* s)
+  void SetCMakeEditCommand(std::string const& s)
     {
       this->CMakeEditCommand = s;
     }
@@ -425,8 +415,6 @@ protected:
 
   cmVariableWatch* VariableWatch;
 
-  ///! Find the full path to one of the cmake programs like ctest, cpack, etc.
-  std::string FindCMakeProgram(const char* name) const;
 private:
   cmake(const cmake&);  // Not implemented.
   void operator=(const cmake&);  // Not implemented.
@@ -443,15 +431,12 @@ private:
   bool CheckSystemVars;
   std::map<cmStdString, bool> UsedCliVariables;
   std::string CMakeEditCommand;
-  std::string CMakeCommand;
   std::string CXXEnvironment;
   std::string CCEnvironment;
   std::string CheckBuildSystemArgument;
   std::string CheckStampFile;
   std::string CheckStampList;
   std::string VSSolutionFile;
-  std::string CTestCommand;
-  std::string CPackCommand;
   bool ClearBuildSystem;
   bool DebugTryCompile;
   cmFileTimeComparison* FileComparison;

Source/cmakemain.cxx

@@ -162,7 +162,7 @@ static void cmakemainProgressCallback(const char *m, float prog,
 int main(int ac, char** av)
 {
   cmSystemTools::EnableMSVCDebugHook();
-  cmSystemTools::FindExecutableDirectory(av[0]);
+  cmSystemTools::FindCMakeResources(av[0]);
   if(ac > 1)
     {
     if(strcmp(av[1], "--build") == 0)
@@ -198,7 +198,6 @@ int do_cmake(int ac, char** av)
     // Construct and print requested documentation.
     cmake hcm;
     hcm.AddCMakePaths();
-    doc.SetCMakeRoot(hcm.GetCacheDefinition("CMAKE_ROOT"));
 
     // the command line args are processed here so that you can do
     // -DCMAKE_MODULE_PATH=/some/path and have this value accessible here

Source/ctest.cxx

@@ -115,7 +115,7 @@ int main (int argc, char *argv[])
 {
   cmSystemTools::DoNotInheritStdPipes();
   cmSystemTools::EnableMSVCDebugHook();
-  cmSystemTools::FindExecutableDirectory(argv[0]);
+  cmSystemTools::FindCMakeResources(argv[0]);
 
   // Dispatch 'ctest --launch' mode directly.
   if(argc >= 2 && strcmp(argv[1], "--launch") == 0)
@@ -151,7 +151,6 @@ int main (int argc, char *argv[])
       {
       cmake hcm;
       hcm.AddCMakePaths();
-      doc.SetCMakeRoot(hcm.GetCacheDefinition("CMAKE_ROOT"));
 
       // Construct and print requested documentation.
       cmCTestScriptHandler* ch =