new arch

1 files changed, 349 insertions, 252 deletions

diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index 1772835..2b9864a 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -17,39 +17,34 @@
 #include "cmake.h"
 #include "time.h"
 #include "cmCacheManager.h"
+#include "cmMakefile.h"
+#include "cmLocalGenerator.h"
 
 // include the generator
 #if defined(_WIN32) && !defined(__CYGWIN__)
-#include "cmMSProjectGenerator.h"
-#include "cmMSDotNETGenerator.h"
-#include "cmBorlandMakefileGenerator.h"
-#include "cmNMakeMakefileGenerator.h"
+#include "cmGlobalVisualStudio6Generator.h"
+#include "cmGlobalVisualStudio7Generator.h"
+#include "cmGlobalBorlandMakefileGenerator.h"
+#include "cmGlobalNMakeMakefileGenerator.h"
 #else
-#include "cmUnixMakefileGenerator.h"
+#include "cmGlobalUnixMakefileGenerator.h"
 #endif
 
 cmake::cmake()
 {
   m_Verbose = false;
-#if defined(_WIN32) && !defined(__CYGWIN__)  
-  this->RegisterGenerator(new cmMSProjectGenerator);
-  this->RegisterGenerator(new cmMSDotNETGenerator);
-  this->RegisterGenerator(new cmNMakeMakefileGenerator);
-  this->RegisterGenerator(new cmBorlandMakefileGenerator);
-#else
-  this->RegisterGenerator(new cmUnixMakefileGenerator);
-#endif
+  m_CacheManager = new cmCacheManager;
+  m_GlobalGenerator = 0;
 }
 
 cmake::~cmake()
 {
-  for(std::map<cmStdString, cmMakefileGenerator*>::iterator i
-        = m_RegisteredGenerators.begin(); 
-      i != m_RegisteredGenerators.end(); ++i)
+  delete m_CacheManager;
+  if (m_GlobalGenerator)
     {
-    delete i->second;
+    delete m_GlobalGenerator;
+    m_GlobalGenerator = 0;
     }
-   m_RegisteredGenerators = std::map<cmStdString, cmMakefileGenerator*>();
 }
 
 
@@ -79,8 +74,7 @@ void cmake::Usage(const char* program)
 }
 
 // Parse the args
-void cmake::SetCacheArgs(cmMakefile& builder,
-                         const std::vector<std::string>& args)
+void cmake::SetCacheArgs(const std::vector<std::string>& args)
 { 
   for(unsigned int i=1; i < args.size(); ++i)
     {
@@ -92,9 +86,7 @@ void cmake::SetCacheArgs(cmMakefile& builder,
       cmCacheManager::CacheEntryType type;
       if(cmCacheManager::ParseEntry(entry.c_str(), var, value, type))
         {
-          this->m_CacheManager.AddCacheEntry(
-            var.c_str(), 
-            value.c_str(),
+          this->m_CacheManager->AddCacheEntry(var.c_str(), value.c_str(),
             "No help, variable specified on the command line.",
             type);
         }
@@ -108,17 +100,46 @@ void cmake::SetCacheArgs(cmMakefile& builder,
       {
       std::string path = arg.substr(2);
       std::cerr << "loading initial cache file " << path.c_str() << "\n";
-      if(!builder.ReadListFile(path.c_str()))
-        {
-        std::cerr << "Error in reading cmake initial cache file:"
-                  << path.c_str() << "\n";
-        }
+      this->ReadListFile(path.c_str());
+      }
+    }
+}
+
+void cmake::ReadListFile(const char *path)
+{
+  // if a generator was not yet created, temporarily create one
+  cmGlobalGenerator *gg = this->GetGlobalGenerator();
+  bool created;
+  
+  // if a generator was not specified use a generic one
+  if (!gg)
+    {
+    gg = new cmGlobalGenerator;
+    gg->SetCMakeInstance(this);
+    created = true;
+    }
+
+  // read in the list file to fill the cache
+  if(path)
+    {
+    cmLocalGenerator *lg = gg->CreateLocalGenerator();
+    lg->SetGlobalGenerator(gg);
+    if (!lg->GetMakefile()->ReadListFile(path))
+      {
+      std::cerr << "Error in reading cmake initial cache file:"
+                << path << "\n";
       }
     }
+  
+  // free generic one if generated
+  if (created)
+    {
+    delete gg;
+    }
 }
 
 // Parse the args
-void cmake::SetArgs(cmMakefile& builder, const std::vector<std::string>& args)
+void cmake::SetArgs(const std::vector<std::string>& args)
 {
   m_Local = false;
   bool directoriesSet = false;
@@ -126,22 +147,22 @@ void cmake::SetArgs(cmMakefile& builder, const std::vector<std::string>& args)
   if (args.size() <= 2)
     {
     directoriesSet = true;
-    builder.SetHomeOutputDirectory
+    this->SetHomeOutputDirectory
       (cmSystemTools::GetCurrentWorkingDirectory().c_str());
-    builder.SetStartOutputDirectory
+    this->SetStartOutputDirectory
       (cmSystemTools::GetCurrentWorkingDirectory().c_str());
     if (args.size() == 2)
       {
-      builder.SetHomeDirectory
+      this->SetHomeDirectory
 	(cmSystemTools::CollapseFullPath(args[1].c_str()).c_str());
-      builder.SetStartDirectory
+      this->SetStartDirectory
 	(cmSystemTools::CollapseFullPath(args[1].c_str()).c_str());
       }
     else
       {
-      builder.SetHomeDirectory
+      this->SetHomeDirectory
 	(cmSystemTools::GetCurrentWorkingDirectory().c_str());
-      builder.SetStartDirectory
+      this->SetStartDirectory
 	(cmSystemTools::GetCurrentWorkingDirectory().c_str());
       }
     }
@@ -153,26 +174,26 @@ void cmake::SetArgs(cmMakefile& builder, const std::vector<std::string>& args)
       {
       directoriesSet = true;
       std::string path = arg.substr(2);
-      builder.SetHomeDirectory(path.c_str());
+      this->SetHomeDirectory(path.c_str());
       }
     else if(arg.find("-S",0) == 0)
       {
       directoriesSet = true;
       m_Local = true;
       std::string path = arg.substr(2);
-      builder.SetStartDirectory(path.c_str());
+      this->SetStartDirectory(path.c_str());
       }
     else if(arg.find("-O",0) == 0)
       {
       directoriesSet = true;
       std::string path = arg.substr(2);
-      builder.SetStartOutputDirectory(path.c_str());
+      this->SetStartOutputDirectory(path.c_str());
       }
     else if(arg.find("-B",0) == 0)
       {
       directoriesSet = true;
       std::string path = arg.substr(2);
-      builder.SetHomeOutputDirectory(path.c_str());
+      this->SetHomeOutputDirectory(path.c_str());
       }
     else if(arg.find("-V",0) == 0)
       {
@@ -189,8 +210,8 @@ void cmake::SetArgs(cmMakefile& builder, const std::vector<std::string>& args)
     else if(arg.find("-G",0) == 0)
       {
       std::string value = arg.substr(2);
-      cmMakefileGenerator* gen = 
-        this->CreateGenerator(value.c_str());
+      cmGlobalGenerator* gen = 
+        this->CreateGlobalGenerator(value.c_str());
       if(!gen)
         {
         cmSystemTools::Error("Could not create named generator ",
@@ -198,47 +219,47 @@ void cmake::SetArgs(cmMakefile& builder, const std::vector<std::string>& args)
         }
       else
         {
-        builder.SetMakefileGenerator(gen);
+        this->SetGlobalGenerator(gen);
         }
       }
     // no option assume it is the path to the source
     else
       {
       directoriesSet = true;
-      builder.SetHomeOutputDirectory
+      this->SetHomeOutputDirectory
         (cmSystemTools::GetCurrentWorkingDirectory().c_str());
-      builder.SetStartOutputDirectory
+      this->SetStartOutputDirectory
         (cmSystemTools::GetCurrentWorkingDirectory().c_str());
-      builder.SetHomeDirectory
+      this->SetHomeDirectory
         (cmSystemTools::CollapseFullPath(arg.c_str()).c_str());
-      builder.SetStartDirectory
+      this->SetStartDirectory
         (cmSystemTools::CollapseFullPath(arg.c_str()).c_str());
       }
     }
   if(!directoriesSet)
     {
-    builder.SetHomeOutputDirectory
+    this->SetHomeOutputDirectory
       (cmSystemTools::GetCurrentWorkingDirectory().c_str());
-    builder.SetStartOutputDirectory
+    this->SetStartOutputDirectory
       (cmSystemTools::GetCurrentWorkingDirectory().c_str());
-    builder.SetHomeDirectory
+    this->SetHomeDirectory
       (cmSystemTools::GetCurrentWorkingDirectory().c_str());
-    builder.SetStartDirectory
+    this->SetStartDirectory
       (cmSystemTools::GetCurrentWorkingDirectory().c_str());
     }
   if (!m_Local)
     {
-    builder.SetStartDirectory(builder.GetHomeDirectory());
-    builder.SetStartOutputDirectory(builder.GetHomeOutputDirectory());
+    this->SetStartDirectory(this->GetHomeDirectory());
+    this->SetStartOutputDirectory(this->GetHomeOutputDirectory());
     }
 }
 
 // at the end of this CMAKE_ROOT and CMAKE_COMMAND should be added to the cache
-int cmake::AddCMakePaths(const std::vector<std::string>& args)
+int cmake::AddCMakePaths(const char *arg0)
 {
   // Find our own executable.
   std::vector<cmStdString> failures;
-  std::string cMakeSelf = args[0];
+  std::string cMakeSelf = arg0;
   cmSystemTools::ConvertToUnixSlashes(cMakeSelf);
   failures.push_back(cMakeSelf);
   cMakeSelf = cmSystemTools::FindProgram(cMakeSelf.c_str());
@@ -268,7 +289,7 @@ int cmake::AddCMakePaths(const std::vector<std::string>& args)
     failures.push_back(cMakeSelf);
     cmStringStream msg;
     msg << "CMAKE can not find the command line program cmake.\n";
-    msg << "  argv[0] = \"" << args[0].c_str() << "\"\n";
+    msg << "  argv[0] = \"" << arg0 << "\"\n";
     msg << "  Attempted paths:\n";
     std::vector<cmStdString>::iterator i;
     for(i=failures.begin(); i != failures.end(); ++i)
@@ -279,7 +300,7 @@ int cmake::AddCMakePaths(const std::vector<std::string>& args)
     return 0;
     }
   // Save the value in the cache
-  this->m_CacheManager.AddCacheEntry
+  this->m_CacheManager->AddCacheEntry
     ("CMAKE_COMMAND",cMakeSelf.c_str(), "Path to CMake executable.",
      cmCacheManager::INTERNAL);
 
@@ -293,7 +314,7 @@ int cmake::AddCMakePaths(const std::vector<std::string>& args)
     }
   if(cmSystemTools::FileExists(editCacheCommand.c_str()))
     {
-    this->m_CacheManager.AddCacheEntry
+    this->m_CacheManager->AddCacheEntry
       ("CMAKE_EDIT_COMMAND", editCacheCommand.c_str(),
        "Path to cache edit program executable.", cmCacheManager::INTERNAL);
     }
@@ -363,7 +384,7 @@ int cmake::AddCMakePaths(const std::vector<std::string>& args)
                          modules.c_str());
     return 0;
     }
-  this->m_CacheManager.AddCacheEntry
+  this->m_CacheManager->AddCacheEntry
     ("CMAKE_ROOT", cMakeRoot.c_str(),
      "Path to CMake installation.", cmCacheManager::INTERNAL);
   return 1;
@@ -371,182 +392,6 @@ int cmake::AddCMakePaths(const std::vector<std::string>& args)
 
 
 
-int cmake::Generate(const std::vector<std::string>& args, bool buildMakefiles)
-{
-   if(args.size() == 1 && !cmSystemTools::FileExists("CMakeLists.txt"))
-    {
-    this->Usage(args[0].c_str());
-    return -1;
-    }
-  // look for obvious request for help
-  for(unsigned int i=1; i < args.size(); ++i)
-    {
-    std::string arg = args[i];
-    if(arg.find("-help",0) != std::string::npos ||
-       arg.find("--help",0) != std::string::npos ||
-       arg.find("/?",0) != std::string::npos ||
-       arg.find("-usage",0) != std::string::npos)
-      {
-      this->Usage(args[0].c_str());
-      return -1;
-      }
-    }
-  // Create a makefile
-  cmMakefile mf;
-  mf.SetCacheManager(&this->m_CacheManager);
-  
-  // extract the directory arguments, could create a Generator
-  this->SetArgs(mf, args);
-  // Read and parse the input makefile
-  mf.MakeStartDirectoriesCurrent();
-  this->m_CacheManager.LoadCache(&mf);
-  if(mf.GetDefinition("CMAKE_HOME_DIRECTORY"))
-    {
-    std::string cacheStart = mf.GetDefinition("CMAKE_HOME_DIRECTORY");
-    cacheStart += "/CMakeLists.txt";
-    std::string currentStart = mf.GetHomeDirectory();
-    currentStart += "/CMakeLists.txt";
-    if(!cmSystemTools::SameFile(cacheStart.c_str(), currentStart.c_str()))
-      {
-      std::string message = "Error: source : ";
-      message += currentStart;
-      message += "\nDoes not match source used to generate cache: ";
-      message += cacheStart;
-      message += "\nRe-run cmake with a different source directory.";
-      cmSystemTools::Error(message.c_str());
-      return -2;
-      }
-    }
-  mf.AddCacheDefinition("CMAKE_HOME_DIRECTORY", mf.GetHomeDirectory(),
-                        "Start directory with the top level CMakeLists.txt file for this project",
-                        cmCacheManager::INTERNAL);
-  
-  // extract command line arguments that might add cache entries
-  this->SetCacheArgs(mf, args);
-
-  // no generator specified on the command line
-  if(!mf.GetMakefileGenerator())
-    {
-    cmMakefileGenerator* gen;
-    const char* genName = mf.GetDefinition("CMAKE_GENERATOR");
-    if(genName)
-      {
-      gen = this->CreateGenerator(genName);
-      }
-    else
-      {
-#if defined(__BORLANDC__)
-      gen = new cmBorlandMakefileGenerator;
-#elif defined(_WIN32) && !defined(__CYGWIN__)  
-      gen = new cmMSProjectGenerator;
-#else
-      gen = new cmUnixMakefileGenerator;
-#endif
-      }
-    if(!gen)
-      {
-      cmSystemTools::Error("Could not create generator");
-      return -1;
-      }
-    mf.SetMakefileGenerator(gen);
-    // add the 
-    }
-  cmMakefileGenerator* gen = mf.GetMakefileGenerator();
-  gen->SetLocal(m_Local);
-  const char* genName = mf.GetDefinition("CMAKE_GENERATOR");
-  if(genName)
-    {
-    if(strcmp(gen->GetName(), genName) != 0)
-      {
-      std::string message = "Error: generator : ";
-      message += gen->GetName();
-      message += "\nDoes not match the generator used previously: ";
-      message += genName;
-      message +=
-        "\nEither remove the CMakeCache.txt file or choose a different"
-        " binary directory.";
-      cmSystemTools::Error(message.c_str());
-      return -2;
-      }
-    }
-  if(!mf.GetDefinition("CMAKE_GENERATOR"))
-    {
-    mf.AddCacheDefinition("CMAKE_GENERATOR",
-                          gen->GetName(),
-                          "Name of generator.",
-                          cmCacheManager::INTERNAL);
-    }
-  
-
-  // setup CMAKE_ROOT and CMAKE_COMMAND
-  if(!this->AddCMakePaths(args))
-    {
-    return -3;
-    }
-
-  // reset any system configuration information
-  cmMakefileGenerator::ClearEnabledLanguages();
-
-  std::string lf = mf.GetStartDirectory();
-  lf +=  "/CMakeLists.txt";
-  if(!mf.ReadListFile(lf.c_str()))
-    {
-    this->Usage(args[0].c_str());
-    return -1;
-    }
-  // if buildMakefiles, then call GenerateMakefile
-  if(buildMakefiles)
-    {
-    mf.GenerateMakefile();
-    }
-  else  // do not build, but let the commands finalize
-    {
-    std::vector<cmMakefile*> makefiles;
-    mf.FindSubDirectoryCMakeListsFiles(makefiles);
-    for(std::vector<cmMakefile*>::iterator i = makefiles.begin();
-      i != makefiles.end(); ++i)
-      {
-      cmMakefile* mf = *i;
-      mf->FinalPass();
-      delete mf;
-      }
-    mf.FinalPass();
-    }
-  
-  
-  // Before saving the cache
-  // if the project did not define one of the entries below, add them now
-  // so users can edit the values in the cache:
-  // LIBRARY_OUTPUT_PATH
-  // EXECUTABLE_OUTPUT_PATH
-  if(!this->m_CacheManager.GetCacheValue("LIBRARY_OUTPUT_PATH"))
-    {
-    this->m_CacheManager.AddCacheEntry("LIBRARY_OUTPUT_PATH", "",
-                                                 "Single output directory for building all libraries.",
-                                                 cmCacheManager::PATH);
-    } 
-  if(!this->m_CacheManager.GetCacheValue("EXECUTABLE_OUTPUT_PATH"))
-    {
-    this->m_CacheManager.AddCacheEntry("EXECUTABLE_OUTPUT_PATH", "",
-                                                 "Single output directory for building all executables.",
-                                                 cmCacheManager::PATH);
-    }  
-  
-  this->m_CacheManager.SaveCache(&mf);
-  
-  if(m_Verbose)
-    {
-    this->m_CacheManager.PrintCache(std::cout);
-    }
-  
-  if(cmSystemTools::GetErrorOccuredFlag())
-    {
-    return -1;
-    }
-  return 0;
-}
-
-
 void CMakeCommandUsage(const char* program)
 {
   cmStringStream errorStream;
@@ -678,39 +523,291 @@ int cmake::CMakeCommand(std::vector<std::string>& args)
 
 void cmake::GetRegisteredGenerators(std::vector<std::string>& names)
 {
-  for(std::map<cmStdString, cmMakefileGenerator*>::iterator i
-        = this->m_RegisteredGenerators.begin(); 
-      i != this->m_RegisteredGenerators.end(); ++i)
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  names.push_back(cmGlobalVisualStudio6Generator::GetActualName());
+  names.push_back(cmGlobalVisualStudio7Generator::GetActualName());
+  names.push_back(cmGlobalBorlandMakefileGenerator::GetActualName());
+  names.push_back(cmGlobalNMakeMakefileGenerator::GetActualName());
+#else
+  names.push_back(cmGlobalUnixMakefileGenerator::GetActualName());
+#endif
+}
+
+cmGlobalGenerator* cmake::CreateGlobalGenerator(const char* name)
+{
+  cmGlobalGenerator *ret = 0;
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  if (!strcmp(name,cmGlobalNMakeMakefileGenerator::GetActualName()))
+    {
+    ret = new cmGlobalNMakeMakefileGenerator;
+    ret->SetCMakeInstance(this);
+    }
+  if (!strcmp(name,cmGlobalVisualStudio6Generator::GetActualName()))
+    {
+    ret = new cmGlobalVisualStudio6Generator;
+    ret->SetCMakeInstance(this);
+    }
+  if (!strcmp(name,cmGlobalVisualStudio7Generator::GetActualName()))
+    {
+    ret = new cmGlobalVisualStudio7Generator;
+    ret->SetCMakeInstance(this);
+    } 
+  if (!strcmp(name,cmGlobalBorlandMakefileGenerator::GetActualName()))
+    {
+    ret = new cmGlobalBorlandMakefileGenerator;
+    ret->SetCMakeInstance(this);
+    }
+#else
+  if (!strcmp(name,cmGlobalUnixMakefileGenerator::GetActualName()))
     {
-    names.push_back(i->first);
+    ret = new cmGlobalUnixMakefileGenerator;
+    ret->SetCMakeInstance(this);
     }
+#endif
+  return ret;
 }
 
+void cmake::SetHomeDirectory(const char* dir) 
+{
+  m_cmHomeDirectory = dir;
+  cmSystemTools::ConvertToUnixSlashes(m_cmHomeDirectory);
+}
 
-void cmake::RegisterGenerator(cmMakefileGenerator* mg)
+void cmake::SetHomeOutputDirectory(const char* lib)
 {
-  std::map<cmStdString, cmMakefileGenerator*>::iterator i = 
-    this->m_RegisteredGenerators.find(mg->GetName());
-  // delete re-registered objects
-  if(i != this->m_RegisteredGenerators.end())
+  m_HomeOutputDirectory = lib;
+  cmSystemTools::ConvertToUnixSlashes(m_HomeOutputDirectory);
+}
+
+void cmake::SetGlobalGenerator(cmGlobalGenerator *gg)
+{
+  // delete the old generator
+  if (m_GlobalGenerator)
     {
-    delete i->second;
+    delete m_GlobalGenerator;
     }
-  this->m_RegisteredGenerators[mg->GetName()] = mg;
+  // set the new
+  m_GlobalGenerator = gg;
+  // set the cmake instance just to be sure
+  gg->SetCMakeInstance(this);
 }
 
-cmMakefileGenerator* cmake::CreateGenerator(const char* name)
+int cmake::Configure(const char *arg0, const std::vector<std::string>* args)
 {
-  std::map<cmStdString, cmMakefileGenerator*>::iterator i;
-  for(i = this->m_RegisteredGenerators.begin();
-      i != this->m_RegisteredGenerators.end(); ++i)
+  // Read in the cache
+  m_CacheManager->LoadCache(this->GetHomeOutputDirectory());
+  if(m_CacheManager->GetCacheValue("CMAKE_HOME_DIRECTORY"))
+    {
+    std::string cacheStart = 
+      m_CacheManager->GetCacheValue("CMAKE_HOME_DIRECTORY");
+    cacheStart += "/CMakeLists.txt";
+    std::string currentStart = this->GetHomeDirectory();
+    currentStart += "/CMakeLists.txt";
+    if(!cmSystemTools::SameFile(cacheStart.c_str(), currentStart.c_str()))
+      {
+      std::string message = "Error: source : ";
+      message += currentStart;
+      message += "\nDoes not match source used to generate cache: ";
+      message += cacheStart;
+      message += "\nRe-run cmake with a different source directory.";
+      cmSystemTools::Error(message.c_str());
+      return -2;
+      }
+    }
+  else
+    {
+    m_CacheManager->AddCacheEntry("CMAKE_HOME_DIRECTORY", 
+                                  this->GetHomeDirectory(),
+                                  "Start directory with the top level CMakeLists.txt file for this project",
+                                  cmCacheManager::INTERNAL);
+    }
+  
+  // extract command line arguments that might add cache entries
+  if (args)
+    {
+    this->SetCacheArgs(*args);
+    }
+
+  // setup CMAKE_ROOT and CMAKE_COMMAND
+  if(!this->AddCMakePaths(arg0))
+    {
+    return -3;
+    }
+  
+  // no generator specified on the command line
+  if(!m_GlobalGenerator)
+    {
+    const char* genName = m_CacheManager->GetCacheValue("CMAKE_GENERATOR");
+    if(genName)
+      {
+      m_GlobalGenerator = this->CreateGlobalGenerator(genName);
+      }
+    else
+      {
+#if defined(__BORLANDC__)
+      this->SetGlobalGenerator(new cmGlobalBorlandMakefileGenerator);
+#elif defined(_WIN32) && !defined(__CYGWIN__)  
+      this->SetGlobalGenerator(new cmGlobalVisualStudio6Generator);
+#else
+      this->SetGlobalGenerator(new cmGlobalUnixMakefileGenerator);
+#endif
+      }
+    if(!m_GlobalGenerator)
+      {
+      cmSystemTools::Error("Could not create generator");
+      return -1;
+      }
+    }
+
+  const char* genName = m_CacheManager->GetCacheValue("CMAKE_GENERATOR");
+  if(genName)
     {
-    cmMakefileGenerator* gen = i->second;
-    if(strcmp(name, gen->GetName()) == 0)
+    if(strcmp(m_GlobalGenerator->GetName(), genName) != 0)
       {
-      return gen->CreateObject();
+      std::string message = "Error: generator : ";
+      message += m_GlobalGenerator->GetName();
+      message += "\nDoes not match the generator used previously: ";
+      message += genName;
+      message +=
+        "\nEither remove the CMakeCache.txt file or choose a different"
+        " binary directory.";
+      cmSystemTools::Error(message.c_str());
+      return -2;
       }
     }
+  if(!m_CacheManager->GetCacheValue("CMAKE_GENERATOR"))
+    {
+    m_CacheManager->AddCacheEntry("CMAKE_GENERATOR", m_GlobalGenerator->GetName(),
+                                  "Name of generator.",
+                                  cmCacheManager::INTERNAL);
+    }
+
+  // reset any system configuration information
+  m_GlobalGenerator->ClearEnabledLanguages();
+
+  // actually do the configure
+  m_GlobalGenerator->Configure();
+  
+  // Before saving the cache
+  // if the project did not define one of the entries below, add them now
+  // so users can edit the values in the cache:
+  // LIBRARY_OUTPUT_PATH
+  // EXECUTABLE_OUTPUT_PATH
+  if(!m_CacheManager->GetCacheValue("LIBRARY_OUTPUT_PATH"))
+    {
+    m_CacheManager->AddCacheEntry("LIBRARY_OUTPUT_PATH", "",
+                                  "Single output directory for building all libraries.",
+                                  cmCacheManager::PATH);
+    } 
+  if(!m_CacheManager->GetCacheValue("EXECUTABLE_OUTPUT_PATH"))
+    {
+    m_CacheManager->AddCacheEntry("EXECUTABLE_OUTPUT_PATH", "",
+                                  "Single output directory for building all executables.",
+                                  cmCacheManager::PATH);
+    }  
+  
+  this->m_CacheManager->SaveCache(this->GetHomeOutputDirectory());
+  if(cmSystemTools::GetErrorOccuredFlag())
+    {
+    return -1;
+    }
   return 0;
 }
 
+// handle a command line invocation
+int cmake::Run(const std::vector<std::string>& args)
+{
+  // a quick check for args
+  if(args.size() == 1 && !cmSystemTools::FileExists("CMakeLists.txt"))
+    {
+    this->Usage(args[0].c_str());
+    return -1;
+    }
+
+  // look for obvious request for help
+  for(unsigned int i=1; i < args.size(); ++i)
+    {
+    std::string arg = args[i];
+    if(arg.find("-help",0) != std::string::npos ||
+       arg.find("--help",0) != std::string::npos ||
+       arg.find("/?",0) != std::string::npos ||
+       arg.find("-usage",0) != std::string::npos)
+      {
+      this->Usage(args[0].c_str());
+      return -1;
+      }
+    }
+
+  // Process the arguments
+  this->SetArgs(args);
+  
+  // if we are local do the local thing, otherwise do global
+  if (m_Local)
+    {
+    return this->LocalGenerate();
+    }
+
+  // otherwise global
+  int ret = this->Configure(args[0].c_str(),&args);
+  if (ret)
+    {
+    return ret;
+    }
+  return this->Generate();
+}
+
+int cmake::Generate()
+{
+  m_GlobalGenerator->Generate();
+  if(cmSystemTools::GetErrorOccuredFlag())
+    {
+    return -1;
+    }
+  return 0;
+}
+
+int cmake::LocalGenerate()
+{
+  // Read in the cache
+  m_CacheManager->LoadCache(this->GetHomeOutputDirectory());
+
+  // create the generator based on the cache if it isn't already there
+  const char* genName = m_CacheManager->GetCacheValue("CMAKE_GENERATOR");
+  if(genName)
+    {
+    m_GlobalGenerator = this->CreateGlobalGenerator(genName);
+    }
+  else
+    {
+    cmSystemTools::Error("Could local Generate called without the GENERATOR being specified in the CMakeCache");
+    return -1;
+    }
+  
+  // do the local generate
+  m_GlobalGenerator->LocalGenerate();
+  if(cmSystemTools::GetErrorOccuredFlag())
+    {
+    return -1;
+    }
+  return 0;
+}
+
+unsigned int cmake::GetMajorVersion() 
+{ 
+  return cmMakefile::GetMajorVersion();
+}
+
+unsigned int cmake::GetMinorVersion()
+{ 
+  return cmMakefile::GetMinorVersion();
+}
+
+const char *cmake::GetReleaseVersion()
+{ 
+  return cmMakefile::GetReleaseVersion();
+}
+
+const char* cmake::GetCacheDefinition(const char* name) const
+{
+  return m_CacheManager->GetCacheValue(name);
+}