summaryrefslogtreecommitdiffstats
path: root/Source/cmake.cxx
diff options
context:
space:
mode:
authorKen Martin <ken.martin@kitware.com>2002-09-06 17:06:23 (GMT)
committerKen Martin <ken.martin@kitware.com>2002-09-06 17:06:23 (GMT)
commit25ff4552b3d17c9c4f601c7f488710c4350323d1 (patch)
tree79475f5fb9965ad672bb85ae245130f63e632cce /Source/cmake.cxx
parent2c7e9b3b59cda840adc2aa4c3bfe1ffa0707be99 (diff)
downloadCMake-25ff4552b3d17c9c4f601c7f488710c4350323d1.zip
CMake-25ff4552b3d17c9c4f601c7f488710c4350323d1.tar.gz
CMake-25ff4552b3d17c9c4f601c7f488710c4350323d1.tar.bz2
new arch
Diffstat (limited to 'Source/cmake.cxx')
-rw-r--r--Source/cmake.cxx601
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);
+}