ENH: first pass at cache, clean up the unix generator, clean up configure.in some

Source/CMakeBuildTargets.cxx

@@ -17,14 +17,27 @@
 #include "cmStandardIncludes.h"
 #include "cmMakeDepend.h"
 #include "cmUnixMakefileGenerator.h"
+#include "cmCacheManager.h"
 
+void Usage(const char* program)
+{
+  std::cerr << "Usage: " << program << " CMakeLists.txt " 
+            << "-Ssource_start_directory "
+            << "-Ooutput_start_directory "
+            << "-Hsource_home_directory "
+            << "-Boutput_home_directory\n"
+            << "Where start directories are the current place in the tree,"
+    "and the home directories are the top.\n";
+}
+
+  
 // This is the main program used to gentrate makefile fragments 
 // from CMakeLists.txt input files.   
 int main(int ac, char** av)
 {
   if(ac < 2)
     {
-    std::cerr << "Usage: " << av[0] << " Makefile.in  -Ipath ..." << std::endl;
+    Usage(av[0]);
     return -1;
     }
   // Create a makefile
@@ -66,10 +79,12 @@ int main(int ac, char** av)
 
   // Read and parse the input makefile
   mf.MakeStartDirectoriesCurrent();
+  cmCacheManager::GetInstance()->LoadCache(&mf);
   if(!mf.ReadListFile(av[1]))
     {
-    std::cerr << "Usage: " << av[0] << " Makefile.in  -Ipath ..." << std::endl;
+    Usage(av[0]);
     return -1;
     }
   mf.GenerateMakefile();
+  cmCacheManager::GetInstance()->SaveCache(&mf);
 }

Source/CMakeSetupCMD.cxx

@@ -16,6 +16,7 @@
 #include "cmStandardIncludes.h"
 #include "cmMakefile.h"
 #include "cmMSProjectGenerator.h"
+#include "cmCacheManager.h"
 
 
 // this is the command line version of CMakeSetup.
@@ -59,13 +60,13 @@ int main(int ac, char** av)
   if(ac < 3)
     {
     std::cerr << "Usage: " << av[0] << 
-      " CMakeLists.txt -[DSP|DSW] -Hinsighthome -Dcurrentdir"
-      " -Ooutput directory" << std::endl;
+      " CMakeLists.txt -[DSP|DSW] -Hsource_home  -Sstart_source_directory "
+      " -Ostart_output_directory -Boutput_home" << std::endl;
     return -1;
     }
   std::string arg = av[2];
-  cmMakefile builder;
-  SetArgs(builder, ac, av);
+  cmMakefile makefile;
+  SetArgs(makefile, ac, av);
   cmMSProjectGenerator* pg = new cmMSProjectGenerator;
   if(arg.find("-DSP", 0) != std::string::npos)
     {
@@ -75,10 +76,12 @@ int main(int ac, char** av)
     {
     pg->BuildDSWOn();
     }
-  builder.SetMakefileGenerator(pg);
-  builder.MakeStartDirectoriesCurrent();
-  builder.ReadListFile(av[1]);
-  builder.GenerateMakefile();
+  makefile.SetMakefileGenerator(pg);
+  makefile.MakeStartDirectoriesCurrent();
+  cmCacheManager::GetInstance()->LoadCache(&makefile);
+  makefile.ReadListFile(av[1]);
+  makefile.GenerateMakefile();
+  cmCacheManager::GetInstance()->SaveCache(&makefile);
   return 0;
 }
 

Source/MFCDialog/CMakeSetupDialog.cpp

@@ -7,6 +7,7 @@
 #include "../cmDSWMakefile.h"
 #include "../cmWindowsConfigure.h"
 #include "../cmMSProjectGenerator.h"
+#include "../cmCacheManager.h"
 #ifdef _DEBUG
 #define new DEBUG_NEW
 #undef THIS_FILE
@@ -266,10 +267,13 @@ void CMakeSetupDialog::OnOK()
   CString makefileIn = m_WhereSource;
   makefileIn += "/CMakeLists.txt";
   mf.MakeStartDirectoriesCurrent();
+  // Create a string for the cache file
+  cmCacheManager::GetInstance()->LoadCache(&mf);
   mf.ReadListFile(makefileIn);
   // Move this to the cache editor
   mf.GenerateMakefile();
   CDialog::OnOK();
+  cmCacheManager::GetInstance()->SaveCache(&mf);
   this->SaveToRegistry();
 }
 

Source/MFCDialog/resource.h

-//{{NO_DEPENDENCIES}}
-// Microsoft Developer Studio generated include file.
-// Used by CMakeSetup.rc
-//
-#define IDM_ABOUTBOX                    0x0010
-#define IDD_ABOUTBOX                    100
-#define IDS_ABOUTBOX                    101
-#define IDD_CMakeSetupDialog_DIALOG     102
-#define IDR_MAINFRAME                   128
-#define IDC_WhereSource                 1001
-#define IDC_BUTTON2                     1002
-#define IDC_WhereBuild                  1003
-#define IDC_BUTTON3                     1004
-
-// Next default values for new objects
-// 
-#ifdef APSTUDIO_INVOKED
-#ifndef APSTUDIO_READONLY_SYMBOLS
-#define _APS_NEXT_RESOURCE_VALUE        129
-#define _APS_NEXT_COMMAND_VALUE         32771
-#define _APS_NEXT_CONTROL_VALUE         1003
-#define _APS_NEXT_SYMED_VALUE           101
-#endif
-#endif
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by CMakeSetup.rc
+//
+#define IDM_ABOUTBOX                    0x0010
+#define IDD_ABOUTBOX                    100
+#define IDS_ABOUTBOX                    101
+#define IDD_CMakeSetupDialog_DIALOG     102
+#define IDR_MAINFRAME                   128
+#define IDC_WhereSource                 1001
+#define IDC_BUTTON2                     1002
+#define IDC_WhereBuild                  1003
+#define IDC_BUTTON3                     1004
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        131
+#define _APS_NEXT_COMMAND_VALUE         32771
+#define _APS_NEXT_CONTROL_VALUE         1004
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif

Source/Makefile.in

@@ -21,7 +21,8 @@ cmClassFile.o \
 cmSystemTools.o \
 cmDirectory.o \
 cmUnixMakefileGenerator.o \
-cmCommands.o
+cmCommands.o \
+cmCacheManager.o
 
 
 cmCollectFlags.o : $(srcdir)/*.h 
@@ -35,6 +36,7 @@ cmClassFile.o : $(srcdir)/*.h
 cmDirectory.o : $(srcdir)/*.h
 cmUnixMakefileGenerator.o : $(srcdir)/*.h
 cmCommands.o : $(srcdir)/*.h
+cmCacheManager.o : $(srcdir)/*.h
 
 
 

Source/cmCacheManager.cxx

@@ -16,10 +16,13 @@
 
 #include "cmCacheManager.h"
 #include "cmSystemTools.h"
+#include "cmCacheManager.h"
+#include "cmMakefile.h"
 
 const char* cmCacheManagerTypes[] = 
 { "BOOL",
   "PATH",
+  "FILEPATH",
   "STRING",
   0
 };
@@ -33,6 +36,7 @@ cmCacheManager::CacheEntryType cmCacheManager::StringToType(const char* s)
       {
       return static_cast<CacheEntryType>(i);
       }
+    ++i;
     }
   return STRING;
 }
@@ -51,12 +55,15 @@ cmCacheManager* cmCacheManager::GetInstance()
 
 
 
-bool cmCacheManager::LoadCache(const char* path)
+bool cmCacheManager::LoadCache(cmMakefile* mf)
 {
-  std::ifstream fin(path);
+  std::string cacheFile = mf->GetHomeOutputDirectory();
+  cacheFile += "/CMakeCache.txt";
+  // clear the old cache
+  m_Cache.clear();
+  std::ifstream fin(cacheFile.c_str());
   if(!fin)
     {
-    cmSystemTools::Error("Unable to open cache file for load. ", path);
     return false;
     }
   const int bsize = 4096;
@@ -64,37 +71,45 @@ bool cmCacheManager::LoadCache(const char* path)
   std::string inputLine;
   while(fin)
     {
+    // Format is key:type=value
     CacheEntry e;
     std::string key;
-    fin.getline(buffer, bsize, '|');
+    fin.getline(buffer, bsize, ':');
     key = buffer;
-    fin.getline(buffer, bsize, '|');
-    e.m_Value = buffer;
-    fin.getline(buffer, bsize); // last token is separated by a newline
+    fin.getline(buffer, bsize, '=');
     e.m_Type = cmCacheManager::StringToType(buffer);
+    fin.getline(buffer, bsize); // last token is separated by a newline
+    e.m_Value = buffer;
     if(fin)
       {
       m_Cache[key] = e;
       }
     }
+  return true;
 }
 
-bool cmCacheManager::SaveCache(const char* path)
+bool cmCacheManager::SaveCache(cmMakefile* mf)
 {
-  std::ofstream fout(path);
+  std::string cacheFile = mf->GetHomeOutputDirectory();
+  cacheFile += "/CMakeCache.txt";
+  std::ofstream fout(cacheFile.c_str());
   if(!fout)
     {
-    cmSystemTools::Error("Unable to open cache file for save. ", path);
+    cmSystemTools::Error("Unable to open cache file for save. ", 
+                         cacheFile.c_str());
     return false;
     }
   for( std::map<std::string, CacheEntry>::iterator i = m_Cache.begin();
        i != m_Cache.end(); ++i)
     {
-    fout << (*i).first.c_str() << " | " << (*i).second.m_Value << " | ";
     CacheEntryType t = (*i).second.m_Type;
-    fout << cmCacheManagerTypes[t];
+    // Format is key:type=value
+    fout << (*i).first.c_str() << ":"
+         << cmCacheManagerTypes[t] << "="
+         << (*i).second.m_Value << "\n";
     }
   fout << "\n";
+  return true;
 }
 
 void cmCacheManager::AddCacheEntry(const char* key, 

Source/cmCacheManager.h

@@ -17,6 +17,7 @@
 #define cmCacheManager_h
 
 #include "cmStandardIncludes.h"
+class cmMakefile;
 
 /** \class cmCacheManager
  * \brief Control class for cmake's cache
@@ -31,24 +32,26 @@ public:
    * Types for the cache entries.  These are useful as
    * hints for a cache editor program.  Path should bring
    * up a file chooser, BOOL a check box, and STRING a 
-   * text entry box.
+   * text entry box, FILEPATH is a full path to a file which
+   * can be different than just a path input
    */
-  enum CacheEntryType{ BOOL=0, PATH, STRING  };
+  enum CacheEntryType{ BOOL=0, PATH, FILEPATH, STRING  };
   static CacheEntryType StringToType(const char*);
   //! Singleton pattern get instance of the cmCacheManager.
   static cmCacheManager* GetInstance();
 
-  //! Load a cache from file
-  bool LoadCache(const char* path);
+  //! Load a cache for given makefile.  Loads from ouput home.
+  bool LoadCache(cmMakefile*);
   
-  //! Save the cache to a file
-  bool SaveCache(const char* path);
+  //! Save cache for given makefile.  Saves to ouput home CMakeCache.txt
+  bool SaveCache(cmMakefile*);
   
   //! Add an entry into the cache
   void AddCacheEntry(const char* key, const char* value, CacheEntryType type);
   
   //! Get a value from the cache given a key
   const char* GetCacheValue(const char* key);
+  
 private:
   static cmCacheManager* s_Instance;
   class CacheEntry

Source/cmCommand.h

@@ -53,14 +53,10 @@ public:
   /**
    * This is called at the end after all the information
    * specified by the command is accumulated. Most commands do
-   * not implement this method.
+   * not implement this method.  At this point, reading and
+   * writing to the cache can be done.
    */
   virtual void FinalPass() {};
-
-  /**
-   * This is called to let the command check the cache.
-   */
-  virtual void LoadCache() {}
   
   /**
    * This is a virtual constructor for the command.

Source/cmDSWMakefile.cxx

@@ -165,7 +165,8 @@ void cmDSWMakefile::WriteDSWFile(std::ostream& fout)
     cmSystemTools::ReplaceString(dir, homedir.c_str(), "");
     // Get the list of create dsp files from the cmDSPMakefile, more
     // than one dsp could have been created per input CMakeLists.txt file
-    std::vector<std::string> dspnames = (*k)->GetDSPMakefile()->GetCreatedProjectNames();
+    std::vector<std::string> dspnames =
+      (*k)->GetDSPMakefile()->GetCreatedProjectNames();
     for(std::vector<std::string>::iterator si = dspnames.begin();
 	si != dspnames.end(); ++si)
       {
@@ -188,7 +189,8 @@ void cmDSWMakefile::WriteProject(std::ostream& fout,
                                  cmDSPMakefile* project)
 {
   project->GetMakefile()->ExpandVariables();
-  fout << "###############################################################################\n\n";
+  fout << "#########################################################"
+    "######################\n\n";
   fout << "Project: \"" << dspname << "\"=" 
        << dir << "\\" << dspname << ".dsp - Package Owner=<4>\n\n";
   fout << "Package=<5>\n{{{\n}}}\n\n";
@@ -215,11 +217,13 @@ void cmDSWMakefile::WriteProject(std::ostream& fout,
 
 void cmDSWMakefile::WriteDSWFooter(std::ostream& fout)
 {
-  fout << "###############################################################################\n\n";
+  fout << "######################################################"
+    "#########################\n\n";
   fout << "Global:\n\n";
   fout << "Package=<5>\n{{{\n}}}\n\n";
   fout << "Package=<3>\n{{{\n}}}\n\n";
-  fout << "###############################################################################\n\n";
+  fout << "#####################################################"
+    "##########################\n\n";
 }
 
   

Source/cmDSWWriter.cxx

@@ -165,7 +165,8 @@ void cmDSWMakefile::WriteDSWFile(std::ostream& fout)
     cmSystemTools::ReplaceString(dir, homedir.c_str(), "");
     // Get the list of create dsp files from the cmDSPMakefile, more
     // than one dsp could have been created per input CMakeLists.txt file
-    std::vector<std::string> dspnames = (*k)->GetDSPMakefile()->GetCreatedProjectNames();
+    std::vector<std::string> dspnames =
+      (*k)->GetDSPMakefile()->GetCreatedProjectNames();
     for(std::vector<std::string>::iterator si = dspnames.begin();
 	si != dspnames.end(); ++si)
       {
@@ -188,7 +189,8 @@ void cmDSWMakefile::WriteProject(std::ostream& fout,
                                  cmDSPMakefile* project)
 {
   project->GetMakefile()->ExpandVariables();
-  fout << "###############################################################################\n\n";
+  fout << "#########################################################"
+    "######################\n\n";
   fout << "Project: \"" << dspname << "\"=" 
        << dir << "\\" << dspname << ".dsp - Package Owner=<4>\n\n";
   fout << "Package=<5>\n{{{\n}}}\n\n";
@@ -215,11 +217,13 @@ void cmDSWMakefile::WriteProject(std::ostream& fout,
 
 void cmDSWMakefile::WriteDSWFooter(std::ostream& fout)
 {
-  fout << "###############################################################################\n\n";
+  fout << "######################################################"
+    "#########################\n\n";
   fout << "Global:\n\n";
   fout << "Package=<5>\n{{{\n}}}\n\n";
   fout << "Package=<3>\n{{{\n}}}\n\n";
-  fout << "###############################################################################\n\n";
+  fout << "#####################################################"
+    "##########################\n\n";
 }
 
   

Source/cmFindIncludeCommand.cxx

@@ -14,6 +14,7 @@
 
 =========================================================================*/
 #include "cmFindIncludeCommand.h"
+#include "cmCacheManager.h"
 
 // cmFindIncludeCommand
 bool cmFindIncludeCommand::Invoke(std::vector<std::string>& args)
@@ -23,7 +24,15 @@ bool cmFindIncludeCommand::Invoke(std::vector<std::string>& args)
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  
+  // Now check and see if the value has been stored in the cache
+  // already, if so use that value and don't look for the program
+  const char* cacheValue
+    = cmCacheManager::GetInstance()->GetCacheValue(args[0].c_str());
+  if(cacheValue)
+    {
+    m_Makefile->AddDefinition(args[0].c_str(), cacheValue);
+    return true;
+    }
   std::vector<std::string> path;
   // add any user specified paths
   for (int j = 2; j < args.size(); j++)
@@ -45,8 +54,13 @@ bool cmFindIncludeCommand::Invoke(std::vector<std::string>& args)
     if(cmSystemTools::FileExists(tryPath.c_str()))
       {
       m_Makefile->AddDefinition(args[0].c_str(), path[k].c_str());
+      // Save the value in the cache
+      cmCacheManager::GetInstance()->AddCacheEntry(args[0].c_str(),
+                                                   path[k].c_str(),
+                                                   cmCacheManager::PATH);
       return true;
       }
     }
+  return false;
 }
 

Source/cmFindLibraryCommand.cxx

@@ -14,6 +14,7 @@
 
 =========================================================================*/
 #include "cmFindLibraryCommand.h"
+#include "cmCacheManager.h"
 
 // cmFindLibraryCommand
 bool cmFindLibraryCommand::Invoke(std::vector<std::string>& args)
@@ -23,7 +24,15 @@ bool cmFindLibraryCommand::Invoke(std::vector<std::string>& args)
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  
+  // Now check and see if the value has been stored in the cache
+  // already, if so use that value and don't look for the program
+  const char* cacheValue
+    = cmCacheManager::GetInstance()->GetCacheValue(args[0].c_str());
+  if(cacheValue)
+    {
+    m_Makefile->AddDefinition(args[0].c_str(), cacheValue);
+    return true;
+    }
   std::vector<std::string> path;
   // add any user specified paths
   for (int j = 2; j < args.size(); j++)
@@ -44,9 +53,13 @@ bool cmFindLibraryCommand::Invoke(std::vector<std::string>& args)
     tryPath += args[1];
     if(cmSystemTools::FileExists(tryPath.c_str()))
       {
-      m_Makefile->AddDefinition(args[0].c_str(), path[k].c_str());
+      m_Makefile->AddDefinition(args[0].c_str(), path[k].c_str());  
+      cmCacheManager::GetInstance()->AddCacheEntry(args[0].c_str(),
+                                                   path[k].c_str(),
+                                                   cmCacheManager::PATH);
       return true;
       }
     }
+  return false;
 }
 

Source/cmFindProgramCommand.cxx

@@ -14,6 +14,7 @@
 
 =========================================================================*/
 #include "cmFindProgramCommand.h"
+#include "cmCacheManager.h"
 #include <stdlib.h>
 #include <stdio.h>
   
@@ -26,13 +27,22 @@ bool cmFindProgramCommand::Invoke(std::vector<std::string>& args)
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-
-  std::vector<std::string> path;
-  cmSystemTools::GetPath(path);
-
   std::vector<std::string>::iterator i = args.begin();
+  // Use the first argument as the name of something to be defined
   const char* define = (*i).c_str();
-  i++;
+  i++; // move iterator to next arg
+  // Now check and see if the value has been stored in the cache
+  // already, if so use that value and don't look for the program
+  const char* cacheValue
+    = cmCacheManager::GetInstance()->GetCacheValue(define);
+  if(cacheValue)
+    {
+    m_Makefile->AddDefinition(define, cacheValue);
+    return true;
+    }
+  // if it is not in the cache, then search the system path
+  std::vector<std::string> path;
+  cmSystemTools::GetPath(path);
   for(; i != args.end(); ++i)
     {
     for(int k=0; k < path.size(); k++)
@@ -45,6 +55,10 @@ bool cmFindProgramCommand::Invoke(std::vector<std::string>& args)
 #endif
       if(cmSystemTools::FileExists(tryPath.c_str()))
         {
+        // Save the value in the cache
+        cmCacheManager::GetInstance()->AddCacheEntry(define,
+                                                     tryPath.c_str(),
+                                                     cmCacheManager::FILEPATH);
         m_Makefile->AddDefinition(define, tryPath.c_str());
         return true;
         }

Source/cmIncludeDirectoryCommand.cxx

@@ -14,7 +14,7 @@
 
 =========================================================================*/
 #include "cmIncludeDirectoryCommand.h"
-
+#include "cmCacheManager.h"
 // cmIncludeDirectoryCommand
 bool cmIncludeDirectoryCommand::Invoke(std::vector<std::string>& args)
 {

Source/cmMakefile.cxx

@@ -21,6 +21,7 @@
 #include "cmSystemTools.h"
 #include "cmMakefileGenerator.h"
 #include "cmCommands.h"
+#include "cmCacheManager.h"
 
 // default is not to be building executables
 cmMakefile::cmMakefile()
@@ -170,7 +171,6 @@ bool cmMakefile::ReadListFile(const char* filename)
           cmCommand* rm = (*pos).second;
           cmCommand* usedCommand = rm->Clone();
           usedCommand->SetMakefile(this);
-          usedCommand->LoadCache();
           bool keepCommand = false;
           if(usedCommand->GetEnabled())
             {

Source/cmRegularExpression.h

@@ -56,7 +56,7 @@ const int NSUBEXP = 10;
  * regular  expression  is  a  sequence  of  characters used to
  * search for exact character matches. However, many times  the
  * exact  sequence to be found is not known, or only a match at
- * the beginning or end of a string is desired. The vbl  regu-
+ * the beginning or end of a string is desired. The cmRegularExpression regu-
  * lar  expression  class implements regular expression pattern
  * matching as is found and implemented in many  UNIX  commands
  * and utilities.
@@ -68,7 +68,7 @@ const int NSUBEXP = 10;
  *    
  * Is written as follows in C++
  *
- *    vbl_reg_exp re("([a-z]+)\\.cc");
+ *    cmRegularExpression re("([a-z]+)\\.cc");
  *    re.find(filename);
  *    cerr << re.match(1);
  *

Source/cmSystemTools.cxx

@@ -146,7 +146,8 @@ void cmSystemTools::ConvertToUnixSlashes(std::string& path)
 }
 
 
-int cmSystemTools::Grep(const char* dir, const char* file, const char* expression)
+int cmSystemTools::Grep(const char* dir, const char* file, 
+                        const char* expression)
 {
   std::string path = dir;
   path += "/";
@@ -327,7 +328,7 @@ void cmSystemTools::Error(const char* m1, const char* m2)
     message += m2;
     }
 #ifdef _WIN32
-//  MessageBox(0, message.c_str(), 0, MB_OK);
+  ::MessageBox(0, message.c_str(), 0, MB_OK);
   std::cerr << message.c_str() << std::endl;
 #else
   std::cerr << message.c_str() << std::endl;

Source/cmUnixMakefileGenerator.h

@@ -42,6 +42,12 @@ public:
 
 protected:
   void OutputMakefile(const char* file);
+  void OutputMakeFlags(std::ostream&);
+  void OutputVerbatim(std::ostream&);
+  void OutputSourceToObjectList(std::ostream& fout);
+  void OutputExecutableRules(std::ostream&);
+  void OutputSubDirectoryRules(std::ostream&);
+  void OutputDependInformation(std::ostream&);
   void OutputDependLibraries(std::ostream&);
 };
 

configure.in.sample

@@ -583,7 +583,7 @@ if test "x$srcdir" = x.; then
 else
     allDirs=`echo $allDirs | sed -e "s|$srcdir/||g"`
 fi
-SUBDIR_MAKEFILES=`echo $allDirs | sed -e 's|\\([[A-Za-z0-9_/]][[A-Za-z0-9_/]]*\\)|\1/Makefile:CMake/MakefileTemplate.in|g'`
+SUBDIR_MAKEFILES=`echo $allDirs | sed -e 's|\\([[A-Za-z0-9_/]][[A-Za-z0-9_/]]*\\)|\1/Makefile:CMake/CMakeMakefileTemplate.in|g'`
 
 SUBDIR_CMAKE_TARGETS=`echo $allDirs | sed -e 's|\\([[A-Za-z0-9_/]][[A-Za-z0-9_/]]*\\)|\1/CMakeTargets.make:CMake/CMakeTargets.make.in|g'`
 
@@ -601,7 +601,7 @@ SUBDIR_CMAKE_TARGETS=`echo $allDirs | sed -e 's|\\([[A-Za-z0-9_/]][[A-Za-z0-9_/]
 # sub directories found in CMakeLists.txt files
 
 AC_OUTPUT(
-Makefile:CMake/MakefileTemplate.in
+Makefile:CMake/CMakeMakefileTemplate.in
 CMakeTargets.make:CMake/CMakeTargets.make.in 
 CMake/CMakeSimpleRules.make 
 CMake/CMakeMaster.make