ENH: Added UTILITY_SOURCE command for specifying where a 3rd party utility's source is located when it is included in the distribution of a project.

Source/cmCommands.cxx

@@ -39,6 +39,7 @@
 #include "cmWrapExcludeFilesCommand.cxx"
 #include "cmWrapTclCommand.cxx"
 #include "cmBuildSharedLibrariesCommand.cxx"
+#include "cmUtilitySourceCommand.cxx"
 
 void GetPredefinedCommands(std::list<cmCommand*>& commands)
 {
@@ -75,6 +76,7 @@ void GetPredefinedCommands(std::list<cmCommand*>& commands)
   commands.push_back(new cmWrapExcludeFilesCommand);  
   commands.push_back(new cmWrapTclCommand);
   commands.push_back(new cmBuildSharedLibrariesCommand);
+  commands.push_back(new cmUtilitySourceCommand);
 }
 
   

Source/cmMakefile.cxx

@@ -29,6 +29,7 @@ cmMakefile::cmMakefile()
   m_DefineFlags = " ";
   m_MakefileGenerator = 0;
   this->AddDefaultCommands();
+  this->AddDefaultDefinitions();
 }
 
 void cmMakefile::AddDefaultCommands()
@@ -524,4 +525,16 @@ void cmMakefile::GenerateCacheOnly()
 }
 
 
-
+/**
+ * Add the default definitions to the makefile.  These values must not
+ * be dependent on anything that isn't known when this cmMakefile instance
+ * is constructed.
+ */
+void cmMakefile::AddDefaultDefinitions()
+{
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  this->AddDefinition("CMAKE_CFG","$(CFG)");
+#else
+  this->AddDefinition("CMAKE_CFG",".");
+#endif
+}

Source/cmMakefile.h

@@ -420,7 +420,7 @@ private:
 				// to the m_Classes array 
   void PrintStringVector(const char* s, std::vector<std::string>& v);
   void AddDefaultCommands();
-  
+  void AddDefaultDefinitions();
 };
 
 

Source/cmSystemTools.cxx

@@ -65,6 +65,17 @@ void cmSystemTools::GetPath(std::vector<std::string>& path)
     }
 }
 
+
+const char* cmSystemTools::GetExecutableExtension()
+{
+#if defined(_WIN32)
+  return ".exe";
+#else
+  return "";
+#endif  
+}
+
+
 bool cmSystemTools::MakeDirectory(const char* path)
 {
   std::string dir = path;

Source/cmSystemTools.h

@@ -85,6 +85,12 @@ public:
    */
   static void GetPath(std::vector<std::string>& path);
 
+  /**
+   *  Get the file extension (including ".") needed for an executable
+   *  on the current platform ("" for unix, ".exe" for Windows).
+   */
+  static const char* GetExecutableExtension();
+  
   /**
    * Display an error message.
    */

Source/cmUtilitySourceCommand.cxx

@@ -0,0 +1,81 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+
+  Copyright (c) 2000 National Library of Medicine
+  All rights reserved.
+
+  See COPYRIGHT.txt for copyright details.
+
+=========================================================================*/
+#include "cmUtilitySourceCommand.h"
+
+// cmUtilitySourceCommand
+bool cmUtilitySourceCommand::Invoke(std::vector<std::string>& args)
+{
+  if(args.size() < 3)
+    {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+    }
+  
+  std::vector<std::string>::const_iterator arg = args.begin();
+  
+  // The first argument is the cache entry name.
+  std::string cacheEntry = *arg++;
+  const char* cacheValue =
+    cmCacheManager::GetInstance()->GetCacheValue(cacheEntry.c_str());
+  // If it exists already, we are done.
+  if(cacheValue)
+    {
+    // Set the makefile's definition with the cache value.
+    m_Makefile->AddDefinition(cacheEntry.c_str(), cacheValue);
+    return true;
+    }
+  
+  // The second argument is the utility's executable name, which will be
+  // needed later.
+  std::string utilityName = *arg++;
+  
+  // The third argument specifies the relative directory of the source
+  // of the utility.
+  std::string relativeSource = *arg++;
+  std::string utilitySource = m_Makefile->GetCurrentDirectory();
+  utilitySource = utilitySource+"/"+relativeSource;
+  
+  // If the directory doesn't exist, the source has not been included.
+  if(!cmSystemTools::FileExists(utilitySource.c_str()))
+    { return true; }
+  
+  // Make sure all the files exist in the source directory.
+  while(arg != args.end())
+    {
+    std::string file = utilitySource+"/"+*arg++;
+    if(!cmSystemTools::FileExists(file.c_str()))
+      { return true; }
+    }
+  
+  // The source exists.  Construct the cache entry for the executable's
+  // location.
+  std::string cmakeCFG = m_Makefile->GetDefinition("CMAKE_CFG");
+  std::string utilityExecutable = m_Makefile->GetCurrentOutputDirectory();
+  utilityExecutable =
+    (utilityExecutable+"/"+relativeSource+"/"+cmakeCFG+"/"
+     +utilityName+cmSystemTools::GetExecutableExtension());
+  
+  // Enter the value into the cache.
+  cmCacheManager::GetInstance()->AddCacheEntry(cacheEntry.c_str(),
+                                               utilityExecutable.c_str(),
+                                               cmCacheManager::FILEPATH);
+  
+  // Set the definition in the makefile.
+  m_Makefile->AddDefinition(cacheEntry.c_str(), utilityExecutable.c_str());
+  
+  return true;
+}
+

Source/cmUtilitySourceCommand.h

@@ -0,0 +1,80 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+
+  Copyright (c) 2000 National Library of Medicine
+  All rights reserved.
+
+  See COPYRIGHT.txt for copyright details.
+
+=========================================================================*/
+#ifndef cmUtilitySourceCommand_h
+#define cmUtilitySourceCommand_h
+
+#include "cmStandardIncludes.h"
+#include "cmCommand.h"
+
+/** \class cmUtilitySourceCommand
+ * \brief A command to setup a cache entry with the location of a third-party
+ * utility's source.
+ *
+ * cmUtilitySourceCommand is used when a third-party utility's source is
+ * included in the project's source tree.  It specifies the location of
+ * the executable's source, and any files that may be needed to confirm the
+ * identity of the source.
+ */
+class cmUtilitySourceCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  virtual cmCommand* Clone() 
+    {
+    return new cmUtilitySourceCommand;
+    }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  virtual bool Invoke(std::vector<std::string>& args);
+
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  virtual const char* GetName() { return "UTILITY_SOURCE";}
+
+  /**
+   * Succinct documentation.
+   */
+  virtual const char* GetTerseDocumentation() 
+    {
+    return "Specify the source tree of a third-party utility.";
+    }
+  
+  /**
+   * More documentation.
+   */
+  virtual const char* GetFullDocumentation()
+    {
+    return
+      "UTILITY_SOURCE(cache_entry executable_name path_to_source [file1 file2 ...])\n"
+      "When a third-party utility's source is included in the distribution,\n"
+      "this command specifies its location and name.  The cache entry will\n"
+      "not be set unless the path_to_source and all listed files exist.  It\n"
+      "is assumed that the source tree of the utility will have been built\n"
+      "before it is needed.";
+    }
+  
+  cmTypeMacro(cmUtilitySourceCommand, cmCommand);
+};
+
+
+
+#endif