| /*========================================================================= |
| |
| Program: CMake - Cross-Platform Makefile Generator |
| Module: $RCSfile$ |
| Language: C++ |
| Date: $Date$ |
| Version: $Revision$ |
| |
| Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. |
| See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details. |
| |
| This software is distributed WITHOUT ANY WARRANTY; without even |
| the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| PURPOSE. See the above copyright notices for more information. |
| |
| =========================================================================*/ |
| #include "cmake.h" |
| #include "time.h" |
| #include "cmCacheManager.h" |
| #include "cmMakefile.h" |
| #include "cmLocalGenerator.h" |
| #include "cmCommands.h" |
| #include "cmCommand.h" |
| #include "cmFileTimeComparison.h" |
| #include "cmGeneratedFileStream.h" |
| |
| #if defined(CMAKE_BUILD_WITH_CMAKE) |
| # include "cmDependsFortran.h" // For -E cmake_copy_f90_mod callback. |
| # include "cmVariableWatch.h" |
| # include "cmVersion.h" |
| #endif |
| |
| // only build kdevelop generator on non-windows platforms |
| // when not bootstrapping cmake |
| #if !defined(_WIN32) |
| # if defined(CMAKE_BUILD_WITH_CMAKE) |
| # define CMAKE_USE_KDEVELOP |
| # endif |
| #endif |
| |
| #if defined(__MINGW32__) && !defined(CMAKE_BUILD_WITH_CMAKE) |
| # define CMAKE_BOOT_MINGW |
| #endif |
| |
| // include the generator |
| #if defined(_WIN32) && !defined(__CYGWIN__) |
| # if !defined(CMAKE_BOOT_MINGW) |
| # include "cmGlobalVisualStudio6Generator.h" |
| # include "cmGlobalVisualStudio7Generator.h" |
| # include "cmGlobalVisualStudio71Generator.h" |
| # include "cmGlobalVisualStudio8Generator.h" |
| # include "cmGlobalVisualStudio8Win64Generator.h" |
| # include "cmGlobalBorlandMakefileGenerator.h" |
| # include "cmGlobalNMakeMakefileGenerator.h" |
| # include "cmGlobalWatcomWMakeGenerator.h" |
| # endif |
| # include "cmGlobalMSYSMakefileGenerator.h" |
| # include "cmGlobalMinGWMakefileGenerator.h" |
| # include "cmWin32ProcessExecution.h" |
| #else |
| #endif |
| #include "cmGlobalUnixMakefileGenerator3.h" |
| |
| #ifdef CMAKE_USE_KDEVELOP |
| # include "cmGlobalKdevelopGenerator.h" |
| #endif |
| |
| #include <stdlib.h> // required for atoi |
| |
| #if defined( __APPLE__ ) |
| # if defined(CMAKE_BUILD_WITH_CMAKE) |
| # include "cmGlobalXCodeGenerator.h" |
| # define CMAKE_USE_XCODE 1 |
| # endif |
| # include <sys/types.h> |
| # include <sys/time.h> |
| # include <sys/resource.h> |
| #endif |
| |
| #include <sys/stat.h> // struct stat |
| |
| #include <memory> // auto_ptr |
| |
| void cmNeedBackwardsCompatibility(const std::string& variable, |
| int access_type, void* ) |
| { |
| #ifdef CMAKE_BUILD_WITH_CMAKE |
| if (access_type == cmVariableWatch::UNKNOWN_VARIABLE_READ_ACCESS) |
| { |
| std::string message = "An attempt was made to access a variable: "; |
| message += variable; |
| message += |
| " that has not been defined. Some variables were always defined " |
| "by CMake in versions prior to 1.6. To fix this you might need to set " |
| "the cache value of CMAKE_BACKWARDS_COMPATIBILITY to 1.4 or less. If " |
| "you are writing a CMakeList file, (or have already set " |
| "CMAKE_BACKWARDS_COMPATABILITY to 1.4 or less) then you probably need " |
| "to include a CMake module to test for the feature this variable " |
| "defines."; |
| cmSystemTools::Error(message.c_str()); |
| } |
| #else |
| (void)variable; |
| (void)access_type; |
| #endif |
| } |
| |
| cmake::cmake() |
| { |
| this->DebugTryCompile = false; |
| this->ClearBuildSystem = false; |
| this->FileComparison = new cmFileTimeComparison; |
| |
| #ifdef __APPLE__ |
| struct rlimit rlp; |
| if(!getrlimit(RLIMIT_STACK, &rlp)) |
| { |
| if(rlp.rlim_cur != rlp.rlim_max) |
| { |
| rlp.rlim_cur = rlp.rlim_max; |
| setrlimit(RLIMIT_STACK, &rlp); |
| } |
| } |
| #endif |
| |
| // If MAKEFLAGS are given in the environment, remove the environment |
| // variable. This will prevent try-compile from succeeding when it |
| // should fail (if "-i" is an option). We cannot simply test |
| // whether "-i" is given and remove it because some make programs |
| // encode the MAKEFLAGS variable in a strange way. |
| if(getenv("MAKEFLAGS")) |
| { |
| cmSystemTools::PutEnv("MAKEFLAGS="); |
| } |
| |
| this->Verbose = false; |
| this->InTryCompile = false; |
| this->CacheManager = new cmCacheManager; |
| this->GlobalGenerator = 0; |
| this->ProgressCallback = 0; |
| this->ProgressCallbackClientData = 0; |
| this->ScriptMode = false; |
| |
| #ifdef CMAKE_BUILD_WITH_CMAKE |
| this->VariableWatch = new cmVariableWatch; |
| this->VariableWatch->AddWatch("CMAKE_WORDS_BIGENDIAN", |
| cmNeedBackwardsCompatibility); |
| this->VariableWatch->AddWatch("CMAKE_SIZEOF_INT", |
| cmNeedBackwardsCompatibility); |
| this->VariableWatch->AddWatch("CMAKE_X_LIBS", |
| cmNeedBackwardsCompatibility); |
| #endif |
| |
| this->AddDefaultGenerators(); |
| this->AddDefaultCommands(); |
| |
| // Make sure we can capture the build tool output. |
| cmSystemTools::EnableVSConsoleOutput(); |
| } |
| |
| cmake::~cmake() |
| { |
| delete this->CacheManager; |
| if (this->GlobalGenerator) |
| { |
| delete this->GlobalGenerator; |
| this->GlobalGenerator = 0; |
| } |
| for(RegisteredCommandsMap::iterator j = this->Commands.begin(); |
| j != this->Commands.end(); ++j) |
| { |
| delete (*j).second; |
| } |
| #ifdef CMAKE_BUILD_WITH_CMAKE |
| delete this->VariableWatch; |
| #endif |
| delete this->FileComparison; |
| } |
| |
| void cmake::CleanupCommandsAndMacros() |
| { |
| std::vector<cmCommand*> commands; |
| for(RegisteredCommandsMap::iterator j = this->Commands.begin(); |
| j != this->Commands.end(); ++j) |
| { |
| if ( !j->second->IsA("cmMacroHelperCommand") ) |
| { |
| commands.push_back(j->second); |
| } |
| else |
| { |
| delete j->second; |
| } |
| } |
| this->Commands.erase(this->Commands.begin(), this->Commands.end()); |
| std::vector<cmCommand*>::iterator it; |
| for ( it = commands.begin(); it != commands.end(); |
| ++ it ) |
| { |
| this->Commands[cmSystemTools::LowerCase((*it)->GetName())] = *it; |
| } |
| } |
| |
| bool cmake::CommandExists(const char* name) const |
| { |
| std::string sName = cmSystemTools::LowerCase(name); |
| return (this->Commands.find(sName) != this->Commands.end()); |
| } |
| |
| cmCommand *cmake::GetCommand(const char *name) |
| { |
| cmCommand* rm = 0; |
| std::string sName = cmSystemTools::LowerCase(name); |
| RegisteredCommandsMap::iterator pos = this->Commands.find(sName); |
| if (pos != this->Commands.end()) |
| { |
| rm = (*pos).second; |
| } |
| return rm; |
| } |
| |
| void cmake::RenameCommand(const char*oldName, const char* newName) |
| { |
| // if the command already exists, free the old one |
| std::string sOldName = cmSystemTools::LowerCase(oldName); |
| std::string sNewName = cmSystemTools::LowerCase(newName); |
| RegisteredCommandsMap::iterator pos = this->Commands.find(sOldName); |
| if ( pos == this->Commands.end() ) |
| { |
| return; |
| } |
| cmCommand* cmd = pos->second; |
| |
| pos = this->Commands.find(sNewName); |
| if (pos != this->Commands.end()) |
| { |
| delete pos->second; |
| this->Commands.erase(pos); |
| } |
| this->Commands.insert(RegisteredCommandsMap::value_type(sNewName, cmd)); |
| pos = this->Commands.find(sOldName); |
| this->Commands.erase(pos); |
| } |
| |
| void cmake::AddCommand(cmCommand* wg) |
| { |
| std::string name = cmSystemTools::LowerCase(wg->GetName()); |
| // if the command already exists, free the old one |
| RegisteredCommandsMap::iterator pos = this->Commands.find(name); |
| if (pos != this->Commands.end()) |
| { |
| delete pos->second; |
| this->Commands.erase(pos); |
| } |
| this->Commands.insert( RegisteredCommandsMap::value_type(name, wg)); |
| } |
| |
| // Parse the args |
| bool cmake::SetCacheArgs(const std::vector<std::string>& args) |
| { |
| for(unsigned int i=1; i < args.size(); ++i) |
| { |
| std::string arg = args[i]; |
| if(arg.find("-D",0) == 0) |
| { |
| std::string entry = arg.substr(2); |
| if(entry.size() == 0) |
| { |
| entry = args[++i]; |
| } |
| std::string var, value; |
| cmCacheManager::CacheEntryType type = cmCacheManager::UNINITIALIZED; |
| if(cmCacheManager::ParseEntry(entry.c_str(), var, value, type) || |
| cmCacheManager::ParseEntry(entry.c_str(), var, value)) |
| { |
| this->CacheManager->AddCacheEntry(var.c_str(), value.c_str(), |
| "No help, variable specified on the command line.", |
| type); |
| } |
| else |
| { |
| std::cerr << "Parse error in command line argument: " << arg << "\n" |
| << "Should be: VAR:type=value\n"; |
| cmSystemTools::Error("No cmake scrpt provided."); |
| return false; |
| } |
| } |
| else if(arg.find("-C",0) == 0) |
| { |
| std::string path = arg.substr(2); |
| if ( path.size() == 0 ) |
| { |
| path = args[++i]; |
| } |
| std::cerr << "loading initial cache file " << path.c_str() << "\n"; |
| this->ReadListFile(path.c_str()); |
| } |
| else if(arg.find("-P",0) == 0) |
| { |
| i++; |
| std::string path = args[i]; |
| if ( path.size() == 0 ) |
| { |
| cmSystemTools::Error("No cmake script provided."); |
| return false; |
| } |
| this->ReadListFile(path.c_str()); |
| } |
| } |
| return true; |
| } |
| |
| void cmake::ReadListFile(const char *path) |
| { |
| // if a generator was not yet created, temporarily create one |
| cmGlobalGenerator *gg = this->GetGlobalGenerator(); |
| bool created = false; |
| |
| // 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) |
| { |
| std::auto_ptr<cmLocalGenerator> lg(gg->CreateLocalGenerator()); |
| lg->SetGlobalGenerator(gg); |
| lg->GetMakefile()->SetHomeOutputDirectory |
| (cmSystemTools::GetCurrentWorkingDirectory().c_str()); |
| lg->GetMakefile()->SetStartOutputDirectory |
| (cmSystemTools::GetCurrentWorkingDirectory().c_str()); |
| lg->GetMakefile()->SetHomeDirectory |
| (cmSystemTools::GetCurrentWorkingDirectory().c_str()); |
| lg->GetMakefile()->SetStartDirectory |
| (cmSystemTools::GetCurrentWorkingDirectory().c_str()); |
| if (!lg->GetMakefile()->ReadListFile(0, path)) |
| { |
| std::cerr << "Error processing file:" << path << "\n"; |
| } |
| } |
| |
| // free generic one if generated |
| if (created) |
| { |
| delete gg; |
| } |
| } |
| |
| // Parse the args |
| void cmake::SetArgs(const std::vector<std::string>& args) |
| { |
| bool directoriesSet = false; |
| for(unsigned int i=1; i < args.size(); ++i) |
| { |
| std::string arg = args[i]; |
| if(arg.find("-H",0) == 0) |
| { |
| directoriesSet = true; |
| std::string path = arg.substr(2); |
| path = cmSystemTools::CollapseFullPath(path.c_str()); |
| cmSystemTools::ConvertToUnixSlashes(path); |
| this->SetHomeDirectory(path.c_str()); |
| } |
| else if(arg.find("-S",0) == 0) |
| { |
| // There is no local generate anymore. Ignore -S option. |
| } |
| else if(arg.find("-O",0) == 0) |
| { |
| // There is no local generate anymore. Ignore -O option. |
| } |
| else if(arg.find("-B",0) == 0) |
| { |
| directoriesSet = true; |
| std::string path = arg.substr(2); |
| path = cmSystemTools::CollapseFullPath(path.c_str()); |
| cmSystemTools::ConvertToUnixSlashes(path); |
| this->SetHomeOutputDirectory(path.c_str()); |
| } |
| else if((i < args.size()-1) && (arg.find("--check-build-system",0) == 0)) |
| { |
| this->CheckBuildSystemArgument = args[++i]; |
| this->ClearBuildSystem = (atoi(args[++i].c_str()) > 0); |
| } |
| else if(arg.find("-V",0) == 0) |
| { |
| this->Verbose = true; |
| } |
| else if(arg.find("-D",0) == 0) |
| { |
| // skip for now |
| } |
| else if(arg.find("-C",0) == 0) |
| { |
| // skip for now |
| } |
| else if(arg.find("-P",0) == 0) |
| { |
| // skip for now |
| i++; |
| } |
| else if(arg.find("--graphviz=",0) == 0) |
| { |
| std::string path = arg.substr(strlen("--graphviz=")); |
| path = cmSystemTools::CollapseFullPath(path.c_str()); |
| cmSystemTools::ConvertToUnixSlashes(path); |
| this->GraphVizFile = path; |
| if ( this->GraphVizFile.empty() ) |
| { |
| cmSystemTools::Error("No file specified for --graphviz"); |
| } |
| } |
| else if(arg.find("--debug-trycompile",0) == 0) |
| { |
| std::cout << "debug trycompile on\n"; |
| this->DebugTryCompileOn(); |
| } |
| else if(arg.find("-G",0) == 0) |
| { |
| std::string value = arg.substr(2); |
| if(value.size() == 0) |
| { |
| value = args[++i]; |
| } |
| cmGlobalGenerator* gen = |
| this->CreateGlobalGenerator(value.c_str()); |
| if(!gen) |
| { |
| cmSystemTools::Error("Could not create named generator ", |
| value.c_str()); |
| } |
| else |
| { |
| this->SetGlobalGenerator(gen); |
| } |
| } |
| // no option assume it is the path to the source |
| else |
| { |
| directoriesSet = true; |
| this->SetDirectoriesFromFile(arg.c_str()); |
| } |
| } |
| if(!directoriesSet) |
| { |
| this->SetHomeOutputDirectory |
| (cmSystemTools::GetCurrentWorkingDirectory().c_str()); |
| this->SetStartOutputDirectory |
| (cmSystemTools::GetCurrentWorkingDirectory().c_str()); |
| this->SetHomeDirectory |
| (cmSystemTools::GetCurrentWorkingDirectory().c_str()); |
| this->SetStartDirectory |
| (cmSystemTools::GetCurrentWorkingDirectory().c_str()); |
| } |
| |
| this->SetStartDirectory(this->GetHomeDirectory()); |
| this->SetStartOutputDirectory(this->GetHomeOutputDirectory()); |
| } |
| |
| //---------------------------------------------------------------------------- |
| void cmake::SetDirectoriesFromFile(const char* arg) |
| { |
| // Check if the argument refers to a CMakeCache.txt or |
| // CMakeLists.txt file. |
| std::string listPath; |
| std::string cachePath; |
| bool argIsFile = false; |
| if(cmSystemTools::FileIsDirectory(arg)) |
| { |
| std::string path = cmSystemTools::CollapseFullPath(arg); |
| cmSystemTools::ConvertToUnixSlashes(path); |
| std::string cacheFile = path; |
| cacheFile += "/CMakeCache.txt"; |
| std::string listFile = path; |
| listFile += "/CMakeLists.txt"; |
| if(cmSystemTools::FileExists(cacheFile.c_str())) |
| { |
| cachePath = path; |
| } |
| if(cmSystemTools::FileExists(listFile.c_str())) |
| { |
| listPath = path; |
| } |
| } |
| else if(cmSystemTools::FileExists(arg)) |
| { |
| argIsFile = true; |
| std::string fullPath = cmSystemTools::CollapseFullPath(arg); |
| std::string name = cmSystemTools::GetFilenameName(fullPath.c_str()); |
| name = cmSystemTools::LowerCase(name); |
| if(name == "cmakecache.txt") |
| { |
| cachePath = cmSystemTools::GetFilenamePath(fullPath.c_str()); |
| } |
| else if(name == "cmakelists.txt") |
| { |
| listPath = cmSystemTools::GetFilenamePath(fullPath.c_str()); |
| } |
| } |
| else |
| { |
| // Specified file or directory does not exist. Try to set things |
| // up to produce a meaningful error message. |
| std::string fullPath = cmSystemTools::CollapseFullPath(arg); |
| std::string name = cmSystemTools::GetFilenameName(fullPath.c_str()); |
| name = cmSystemTools::LowerCase(name); |
| if(name == "cmakecache.txt" || name == "cmakelists.txt") |
| { |
| argIsFile = true; |
| listPath = cmSystemTools::GetFilenamePath(fullPath.c_str()); |
| } |
| else |
| { |
| listPath = fullPath; |
| } |
| } |
| |
| // If there is a CMakeCache.txt file, use its settings. |
| if(cachePath.length() > 0) |
| { |
| cmCacheManager* cachem = this->GetCacheManager(); |
| cmCacheManager::CacheIterator it = cachem->NewIterator(); |
| if(cachem->LoadCache(cachePath.c_str()) && |
| it.Find("CMAKE_HOME_DIRECTORY")) |
| { |
| this->SetHomeOutputDirectory(cachePath.c_str()); |
| this->SetStartOutputDirectory(cachePath.c_str()); |
| this->SetHomeDirectory(it.GetValue()); |
| this->SetStartDirectory(it.GetValue()); |
| return; |
| } |
| } |
| |
| // If there is a CMakeLists.txt file, use it as the source tree. |
| if(listPath.length() > 0) |
| { |
| this->SetHomeDirectory(listPath.c_str()); |
| this->SetStartDirectory(listPath.c_str()); |
| |
| if(argIsFile) |
| { |
| // Source CMakeLists.txt file given. It was probably dropped |
| // onto the executable in a GUI. Default to an in-source build. |
| this->SetHomeOutputDirectory(listPath.c_str()); |
| this->SetStartOutputDirectory(listPath.c_str()); |
| } |
| else |
| { |
| // Source directory given on command line. Use current working |
| // directory as build tree. |
| std::string cwd = cmSystemTools::GetCurrentWorkingDirectory(); |
| this->SetHomeOutputDirectory(cwd.c_str()); |
| this->SetStartOutputDirectory(cwd.c_str()); |
| } |
| return; |
| } |
| |
| // We didn't find a CMakeLists.txt or CMakeCache.txt file from the |
| // argument. Assume it is the path to the source tree, and use the |
| // current working directory as the build tree. |
| std::string full = cmSystemTools::CollapseFullPath(arg); |
| std::string cwd = cmSystemTools::GetCurrentWorkingDirectory(); |
| this->SetHomeDirectory(full.c_str()); |
| this->SetStartDirectory(full.c_str()); |
| this->SetHomeOutputDirectory(cwd.c_str()); |
| this->SetStartOutputDirectory(cwd.c_str()); |
| } |
| |
| // at the end of this CMAKE_ROOT and CMAKE_COMMAND should be added to the |
| // cache |
| int cmake::AddCMakePaths(const char *arg0) |
| { |
| // Find our own executable. |
| std::vector<cmStdString> failures; |
| std::string cMakeSelf = arg0; |
| cmSystemTools::ConvertToUnixSlashes(cMakeSelf); |
| failures.push_back(cMakeSelf); |
| cMakeSelf = cmSystemTools::FindProgram(cMakeSelf.c_str()); |
| cmSystemTools::ConvertToUnixSlashes(cMakeSelf); |
| if(!cmSystemTools::FileExists(cMakeSelf.c_str())) |
| { |
| #ifdef CMAKE_BUILD_DIR |
| std::string intdir = "."; |
| #ifdef CMAKE_INTDIR |
| intdir = CMAKE_INTDIR; |
| #endif |
| cMakeSelf = CMAKE_BUILD_DIR; |
| cMakeSelf += "/bin/"; |
| cMakeSelf += intdir; |
| cMakeSelf += "/cmake"; |
| cMakeSelf += cmSystemTools::GetExecutableExtension(); |
| #endif |
| } |
| #ifdef CMAKE_PREFIX |
| if(!cmSystemTools::FileExists(cMakeSelf.c_str())) |
| { |
| failures.push_back(cMakeSelf); |
| cMakeSelf = CMAKE_PREFIX "/bin/cmake"; |
| } |
| #endif |
| if(!cmSystemTools::FileExists(cMakeSelf.c_str())) |
| { |
| failures.push_back(cMakeSelf); |
| cmOStringStream msg; |
| msg << "CMAKE can not find the command line program cmake.\n"; |
| msg << " argv[0] = \"" << arg0 << "\"\n"; |
| msg << " Attempted paths:\n"; |
| std::vector<cmStdString>::iterator i; |
| for(i=failures.begin(); i != failures.end(); ++i) |
| { |
| msg << " \"" << i->c_str() << "\"\n"; |
| } |
| cmSystemTools::Error(msg.str().c_str()); |
| return 0; |
| } |
| // Save the value in the cache |
| this->CacheManager->AddCacheEntry |
| ("CMAKE_COMMAND",cMakeSelf.c_str(), "Path to CMake executable.", |
| cmCacheManager::INTERNAL); |
| |
| // Find and save the command to edit the cache |
| std::string editCacheCommand = cmSystemTools::GetFilenamePath(cMakeSelf) + |
| "/ccmake" + cmSystemTools::GetFilenameExtension(cMakeSelf); |
| if( !cmSystemTools::FileExists(editCacheCommand.c_str())) |
| { |
| editCacheCommand = cmSystemTools::GetFilenamePath(cMakeSelf) + |
| "/CMakeSetup" + cmSystemTools::GetFilenameExtension(cMakeSelf); |
| } |
| 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); |
| } |
| if(cmSystemTools::FileExists(editCacheCommand.c_str())) |
| { |
| this->CacheManager->AddCacheEntry |
| ("CMAKE_EDIT_COMMAND", editCacheCommand.c_str(), |
| "Path to cache edit 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::GetProgramPath(cMakeSelf.c_str()); |
| std::string::size_type slashPos = cMakeRoot.rfind("/"); |
| if(slashPos != std::string::npos) |
| { |
| cMakeRoot = cMakeRoot.substr(0, slashPos); |
| } |
| // is there no Modules direcory 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 |
| #ifdef CMAKE_PREFIX |
| if (!cmSystemTools::FileExists(modules.c_str())) |
| { |
| // try compiled in install prefix |
| cMakeRoot = CMAKE_PREFIX CMAKE_DATA_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 direcory there? |
| modules = cMakeRoot + "/Modules/CMake.cmake"; |
| } |
| if (!cmSystemTools::FileExists(modules.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()); |
| return 0; |
| } |
| this->CacheManager->AddCacheEntry |
| ("CMAKE_ROOT", cMakeRoot.c_str(), |
| "Path to CMake installation.", cmCacheManager::INTERNAL); |
| |
| #ifdef _WIN32 |
| std::string comspec = "cmw9xcom.exe"; |
| cmSystemTools::SetWindows9xComspecSubstitute(comspec.c_str()); |
| #endif |
| return 1; |
| } |
| |
| |
| |
| void CMakeCommandUsage(const char* program) |
| { |
| cmOStringStream errorStream; |
| |
| #ifdef CMAKE_BUILD_WITH_CMAKE |
| errorStream |
| << "cmake version " << cmVersion::GetCMakeVersion() << "\n"; |
| #else |
| errorStream |
| << "cmake bootstrap\n"; |
| #endif |
| |
| errorStream |
| << "Usage: " << program << " -E [command] [arguments ...]\n" |
| << "Available commands: \n" |
| << " chdir dir cmd [args]... - run command in a given directory\n" |
| << " copy file destination - copy file to destination (either file or " |
| "directory)\n" |
| << " copy_if_different in-file out-file - copy file if input has " |
| "changed\n" |
| << " copy_directory source destination - copy directory 'source' " |
| "content to directory 'destination'\n" |
| << " compare_files file1 file2 - check if file1 is same as file2\n" |
| << " echo [string]... - displays arguments as text\n" |
| << " environment - display the current enviroment\n" |
| << " remove file1 file2 ... - remove the file(s)\n" |
| << " tar [cxt][vfz] file.tar file/dir1 file/dir2 ... - create a tar.\n" |
| << " time command [args] ... - run command and return elapsed time\n" |
| #if defined(_WIN32) && !defined(__CYGWIN__) |
| << " write_regv key value - write registry value\n" |
| << " delete_regv key - delete registry value\n" |
| << " comspec - on windows 9x use this for RunCommand\n" |
| #else |
| << " create_symlink old new - create a symbolic link new -> old\n" |
| #endif |
| ; |
| |
| cmSystemTools::Error(errorStream.str().c_str()); |
| } |
| |
| int cmake::ExecuteCMakeCommand(std::vector<std::string>& args) |
| { |
| if (args.size() > 1) |
| { |
| // Copy file |
| if (args[1] == "copy" && args.size() == 4) |
| { |
| if(!cmSystemTools::cmCopyFile(args[2].c_str(), args[3].c_str())) |
| { |
| std::cerr << "Error copying file \"" << args[2].c_str() |
| << "\" to \"" << args[3].c_str() << "\".\n"; |
| return 1; |
| } |
| return 0; |
| } |
| |
| // Copy file if different. |
| if (args[1] == "copy_if_different" && args.size() == 4) |
| { |
| if(!cmSystemTools::CopyFileIfDifferent(args[2].c_str(), |
| args[3].c_str())) |
| { |
| std::cerr << "Error copying file (if different) from \"" |
| << args[2].c_str() << "\" to \"" << args[3].c_str() |
| << "\".\n"; |
| return 1; |
| } |
| return 0; |
| } |
| |
| // Copy directory content |
| if (args[1] == "copy_directory" && args.size() == 4) |
| { |
| if(!cmSystemTools::CopyADirectory(args[2].c_str(), args[3].c_str())) |
| { |
| std::cerr << "Error copying directory from \"" |
| << args[2].c_str() << "\" to \"" << args[3].c_str() |
| << "\".\n"; |
| return 1; |
| } |
| return 0; |
| } |
| |
| // Compare files |
| if (args[1] == "compare_files" && args.size() == 4) |
| { |
| if(cmSystemTools::FilesDiffer(args[2].c_str(), args[3].c_str())) |
| { |
| std::cerr << "Files \"" |
| << args[2].c_str() << "\" to \"" << args[3].c_str() |
| << "\" are different.\n"; |
| return 1; |
| } |
| return 0; |
| } |
| |
| // Echo string |
| else if (args[1] == "echo" ) |
| { |
| unsigned int cc; |
| const char* space = ""; |
| for ( cc = 2; cc < args.size(); cc ++ ) |
| { |
| std::cout << space << args[cc]; |
| space = " "; |
| } |
| std::cout << std::endl; |
| return 0; |
| } |
| |
| #if defined(CMAKE_BUILD_WITH_CMAKE) |
| // Command to create a symbolic link. Fails on platforms not |
| // supporting them. |
| else if (args[1] == "environment" ) |
| { |
| std::vector<std::string> env = cmSystemTools::GetEnvironmentVariables(); |
| std::vector<std::string>::iterator it; |
| for ( it = env.begin(); it != env.end(); ++ it ) |
| { |
| std::cout << it->c_str() << std::endl; |
| } |
| return 0; |
| } |
| #endif |
| |
| // Remove file |
| else if (args[1] == "remove" && args.size() > 2) |
| { |
| for (std::string::size_type cc = 2; cc < args.size(); cc ++) |
| { |
| if(args[cc] != "-f") |
| { |
| if(args[cc] == "\\-f") |
| { |
| args[cc] = "-f"; |
| } |
| cmSystemTools::RemoveFile(args[cc].c_str()); |
| } |
| } |
| return 0; |
| } |
| |
| // Clock command |
| else if (args[1] == "time" && args.size() > 2) |
| { |
| std::string command = args[2]; |
| for (std::string::size_type cc = 3; cc < args.size(); cc ++) |
| { |
| command += " "; |
| command += args[cc]; |
| } |
| |
| clock_t clock_start, clock_finish; |
| time_t time_start, time_finish; |
| |
| time(&time_start); |
| clock_start = clock(); |
| |
| cmSystemTools::RunSingleCommand(command.c_str()); |
| |
| clock_finish = clock(); |
| time(&time_finish); |
| |
| double clocks_per_sec = (double)CLOCKS_PER_SEC; |
| std::cout << "Elapsed time: " |
| << (long)(time_finish - time_start) << " s. (time)" |
| << ", " |
| << (double)(clock_finish - clock_start) / clocks_per_sec |
| << " s. (clock)" |
| << "\n"; |
| return 0; |
| } |
| |
| // Command to change directory and run a program. |
| else if (args[1] == "chdir" && args.size() >= 4) |
| { |
| std::string directory = args[2]; |
| if(!cmSystemTools::FileExists(directory.c_str())) |
| { |
| cmSystemTools::Error("Directory does not exist for chdir command: ", |
| args[2].c_str()); |
| return 0; |
| } |
| |
| std::string command = "\""; |
| command += args[3]; |
| command += "\""; |
| for (std::string::size_type cc = 4; cc < args.size(); cc ++) |
| { |
| command += " \""; |
| command += args[cc]; |
| command += "\""; |
| } |
| int retval = 0; |
| int timeout = 0; |
| if ( cmSystemTools::RunSingleCommand(command.c_str(), 0, &retval, |
| directory.c_str(), true, timeout) ) |
| { |
| return retval; |
| } |
| |
| return 1; |
| } |
| |
| // Command to create a symbolic link. Fails on platforms not |
| // supporting them. |
| else if (args[1] == "create_symlink" && args.size() == 4) |
| { |
| return cmSystemTools::CreateSymlink(args[2].c_str(), |
| args[3].c_str())? 0:1; |
| } |
| |
| // Internal CMake shared library support. |
| else if (args[1] == "cmake_symlink_library" && args.size() == 5) |
| { |
| int result = 0; |
| std::string realName = args[2]; |
| std::string soName = args[3]; |
| std::string name = args[4]; |
| if(soName != realName) |
| { |
| std::string fname = cmSystemTools::GetFilenameName(realName); |
| if(cmSystemTools::FileExists(soName.c_str())) |
| { |
| cmSystemTools::RemoveFile(soName.c_str()); |
| } |
| if(!cmSystemTools::CreateSymlink(fname.c_str(), soName.c_str())) |
| { |
| result = 1; |
| } |
| } |
| if(name != soName) |
| { |
| std::string fname = cmSystemTools::GetFilenameName(soName); |
| if(cmSystemTools::FileExists(soName.c_str())) |
| { |
| cmSystemTools::RemoveFile(name.c_str()); |
| } |
| if(!cmSystemTools::CreateSymlink(fname.c_str(), name.c_str())) |
| { |
| result = 1; |
| } |
| } |
| return result; |
| } |
| // Internal CMake versioned executable support. |
| else if (args[1] == "cmake_symlink_executable" && args.size() == 4) |
| { |
| int result = 0; |
| std::string realName = args[2]; |
| std::string name = args[3]; |
| if(name != realName) |
| { |
| std::string fname = cmSystemTools::GetFilenameName(realName); |
| if(cmSystemTools::FileExists(realName.c_str())) |
| { |
| cmSystemTools::RemoveFile(name.c_str()); |
| } |
| if(!cmSystemTools::CreateSymlink(fname.c_str(), name.c_str())) |
| { |
| result = 1; |
| } |
| } |
| return result; |
| } |
| |
| // Internal CMake dependency scanning support. |
| else if (args[1] == "cmake_depends" && args.size() >= 6) |
| { |
| cmake cm; |
| cmGlobalGenerator *ggd = cm.CreateGlobalGenerator(args[2].c_str()); |
| if (ggd) |
| { |
| ggd->SetCMakeInstance(&cm); |
| std::auto_ptr<cmLocalGenerator> lgd(ggd->CreateLocalGenerator()); |
| lgd->SetGlobalGenerator(ggd); |
| return lgd->ScanDependencies(args)? 0 : 2; |
| } |
| return 1; |
| } |
| |
| // Tar files |
| else if (args[1] == "tar" && args.size() > 3) |
| { |
| std::string flags = args[2]; |
| std::string outFile = args[3]; |
| std::vector<cmStdString> files; |
| for (std::string::size_type cc = 4; cc < args.size(); cc ++) |
| { |
| files.push_back(args[cc]); |
| } |
| bool gzip = false; |
| bool verbose = false; |
| if ( flags.find_first_of('z') != flags.npos ) |
| { |
| gzip = true; |
| } |
| if ( flags.find_first_of('v') != flags.npos ) |
| { |
| verbose = true; |
| } |
| |
| if ( flags.find_first_of('t') != flags.npos ) |
| { |
| if ( !cmSystemTools::ListTar(outFile.c_str(), files, gzip, verbose) ) |
| { |
| cmSystemTools::Error("Problem creating tar: ", outFile.c_str()); |
| return 1; |
| } |
| } |
| else if ( flags.find_first_of('c') != flags.npos ) |
| { |
| if ( !cmSystemTools::CreateTar( |
| outFile.c_str(), files, gzip, verbose) ) |
| { |
| cmSystemTools::Error("Problem creating tar: ", outFile.c_str()); |
| return 1; |
| } |
| } |
| else if ( flags.find_first_of('x') != flags.npos ) |
| { |
| if ( !cmSystemTools::ExtractTar( |
| outFile.c_str(), files, gzip, verbose) ) |
| { |
| cmSystemTools::Error("Problem extracting tar: ", outFile.c_str()); |
| return 1; |
| } |
| } |
| return 0; |
| } |
| |
| #if defined(CMAKE_BUILD_WITH_CMAKE) |
| // Internal CMake Fortran module support. |
| else if (args[1] == "cmake_copy_f90_mod" && args.size() >= 4) |
| { |
| return cmDependsFortran::CopyModule(args)? 0 : 1; |
| } |
| #endif |
| |
| #if defined(_WIN32) && !defined(__CYGWIN__) |
| // Write registry value |
| else if (args[1] == "write_regv" && args.size() > 3) |
| { |
| return cmSystemTools::WriteRegistryValue(args[2].c_str(), |
| args[3].c_str()) ? 0 : 1; |
| } |
| |
| // Delete registry value |
| else if (args[1] == "delete_regv" && args.size() > 2) |
| { |
| return cmSystemTools::DeleteRegistryValue(args[2].c_str()) ? 0 : 1; |
| } |
| // Remove file |
| else if (args[1] == "comspec" && args.size() > 2) |
| { |
| unsigned int cc; |
| std::string command = args[2]; |
| for ( cc = 3; cc < args.size(); cc ++ ) |
| { |
| command += " " + args[cc]; |
| } |
| return cmWin32ProcessExecution::Windows9xHack(command.c_str()); |
| } |
| #endif |
| } |
| |
| ::CMakeCommandUsage(args[0].c_str()); |
| return 1; |
| } |
| |
| void cmake::GetRegisteredGenerators(std::vector<std::string>& names) |
| { |
| for(RegisteredGeneratorsMap::const_iterator i = this->Generators.begin(); |
| i != this->Generators.end(); ++i) |
| { |
| names.push_back(i->first); |
| } |
| } |
| |
| cmGlobalGenerator* cmake::CreateGlobalGenerator(const char* name) |
| { |
| RegisteredGeneratorsMap::const_iterator i = this->Generators.find(name); |
| if(i != this->Generators.end()) |
| { |
| cmGlobalGenerator* generator = (i->second)(); |
| generator->SetCMakeInstance(this); |
| return generator; |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| void cmake::SetHomeDirectory(const char* dir) |
| { |
| this->cmHomeDirectory = dir; |
| cmSystemTools::ConvertToUnixSlashes(this->cmHomeDirectory); |
| } |
| |
| void cmake::SetHomeOutputDirectory(const char* lib) |
| { |
| this->HomeOutputDirectory = lib; |
| cmSystemTools::ConvertToUnixSlashes(this->HomeOutputDirectory); |
| } |
| |
| void cmake::SetGlobalGenerator(cmGlobalGenerator *gg) |
| { |
| // delete the old generator |
| if (this->GlobalGenerator) |
| { |
| delete this->GlobalGenerator; |
| // restore the original environment variables CXX and CC |
| // Restor CC |
| std::string env = "CC="; |
| if(this->CCEnvironment.size()) |
| { |
| env += this->CCEnvironment; |
| } |
| cmSystemTools::PutEnv(env.c_str()); |
| env = "CXX="; |
| if(this->CXXEnvironment.size()) |
| { |
| env += this->CXXEnvironment; |
| } |
| cmSystemTools::PutEnv(env.c_str()); |
| } |
| |
| // set the new |
| this->GlobalGenerator = gg; |
| // set the global flag for unix style paths on cmSystemTools as |
| // soon as the generator is set. This allows gmake to be used |
| // on windows. |
| cmSystemTools::SetForceUnixPaths(this->GlobalGenerator->GetForceUnixPaths()); |
| // Save the environment variables CXX and CC |
| const char* cxx = getenv("CXX"); |
| const char* cc = getenv("CC"); |
| if(cxx) |
| { |
| this->CXXEnvironment = cxx; |
| } |
| else |
| { |
| this->CXXEnvironment = ""; |
| } |
| if(cc) |
| { |
| this->CCEnvironment = cc; |
| } |
| else |
| { |
| this->CCEnvironment = ""; |
| } |
| // set the cmake instance just to be sure |
| gg->SetCMakeInstance(this); |
| } |
| |
| int cmake::DoPreConfigureChecks() |
| { |
| // Make sure the Start directory contains a CMakeLists.txt file. |
| std::string srcList = this->GetHomeDirectory(); |
| srcList += "/CMakeLists.txt"; |
| if(!cmSystemTools::FileExists(srcList.c_str())) |
| { |
| cmOStringStream err; |
| if(cmSystemTools::FileIsDirectory(this->GetHomeDirectory())) |
| { |
| err << "The source directory \"" << this->GetHomeDirectory() |
| << "\" does not appear to contain CMakeLists.txt.\n"; |
| } |
| else if(cmSystemTools::FileExists(this->GetHomeDirectory())) |
| { |
| err << "The source directory \"" << this->GetHomeDirectory() |
| << "\" is a file, not a directory.\n"; |
| } |
| else |
| { |
| err << "The source directory \"" << this->GetHomeDirectory() |
| << "\" does not exist.\n"; |
| } |
| err << "Specify --help for usage, or press the help button on the CMake " |
| "GUI."; |
| cmSystemTools::Error(err.str().c_str()); |
| return -2; |
| } |
| |
| // do a sanity check on some values |
| if(this->CacheManager->GetCacheValue("CMAKE_HOME_DIRECTORY")) |
| { |
| std::string cacheStart = |
| this->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 = "The source \""; |
| message += currentStart; |
| message += "\" does not match the source \""; |
| message += cacheStart; |
| message += "\" used to generate cache. "; |
| message += "Re-run cmake with a different source directory."; |
| cmSystemTools::Error(message.c_str()); |
| return -2; |
| } |
| } |
| else |
| { |
| return 0; |
| } |
| return 1; |
| } |
| |
| int cmake::Configure() |
| { |
| // Construct right now our path conversion table before it's too late: |
| this->UpdateConversionPathTable(); |
| this->CleanupCommandsAndMacros(); |
| |
| int res = 0; |
| if ( !this->ScriptMode ) |
| { |
| res = this->DoPreConfigureChecks(); |
| } |
| if ( res < 0 ) |
| { |
| return -2; |
| } |
| if ( !res ) |
| { |
| this->CacheManager->AddCacheEntry |
| ("CMAKE_HOME_DIRECTORY", |
| this->GetHomeDirectory(), |
| "Start directory with the top level CMakeLists.txt file for this " |
| "project", |
| cmCacheManager::INTERNAL); |
| } |
| |
| // set the default BACKWARDS compatibility to the current version |
| if(!this->CacheManager->GetCacheValue("CMAKE_BACKWARDS_COMPATIBILITY")) |
| { |
| char ver[256]; |
| sprintf(ver,"%i.%i",cmMakefile::GetMajorVersion(), |
| cmMakefile::GetMinorVersion()); |
| this->CacheManager->AddCacheEntry |
| ("CMAKE_BACKWARDS_COMPATIBILITY",ver, |
| "For backwards compatibility, what version of CMake commands and " |
| "syntax should this version of CMake allow.", |
| cmCacheManager::STRING); |
| } |
| |
| // no generator specified on the command line |
| if(!this->GlobalGenerator) |
| { |
| const char* genName = this->CacheManager->GetCacheValue("CMAKE_GENERATOR"); |
| if(genName) |
| { |
| this->GlobalGenerator = this->CreateGlobalGenerator(genName); |
| } |
| if(this->GlobalGenerator) |
| { |
| // set the global flag for unix style paths on cmSystemTools as |
| // soon as the generator is set. This allows gmake to be used |
| // on windows. |
| cmSystemTools::SetForceUnixPaths |
| (this->GlobalGenerator->GetForceUnixPaths()); |
| } |
| else |
| { |
| #if defined(__BORLANDC__) && defined(_WIN32) |
| this->SetGlobalGenerator(new cmGlobalBorlandMakefileGenerator); |
| #elif defined(_WIN32) && !defined(__CYGWIN__) && !defined(CMAKE_BOOT_MINGW) |
| std::string installedCompiler; |
| std::string mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft" |
| "\\VisualStudio\\8.0\\Setup;Dbghelp_path]"; |
| cmSystemTools::ExpandRegistryValues(mp); |
| if (!(mp == "/registry")) |
| { |
| installedCompiler = "Visual Studio 8 2005"; |
| } |
| else |
| { |
| mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft" |
| "\\VisualStudio\\7.1;InstallDir]"; |
| cmSystemTools::ExpandRegistryValues(mp); |
| if (!(mp == "/registry")) |
| { |
| installedCompiler = "Visual Studio 7 .NET 2003"; |
| } |
| else |
| { |
| mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft" |
| "\\VisualStudio\\7.0;InstallDir]"; |
| cmSystemTools::ExpandRegistryValues(mp); |
| if (!(mp == "/registry")) |
| { |
| installedCompiler = "Visual Studio 7"; |
| } |
| else |
| { |
| installedCompiler = "Visual Studio 6"; |
| } |
| } |
| } |
| cmGlobalGenerator* gen |
| = this->CreateGlobalGenerator(installedCompiler.c_str()); |
| if(!gen) |
| { |
| gen = new cmGlobalNMakeMakefileGenerator; |
| } |
| this->SetGlobalGenerator(gen); |
| #else |
| this->SetGlobalGenerator(new cmGlobalUnixMakefileGenerator3); |
| #endif |
| } |
| if(!this->GlobalGenerator) |
| { |
| cmSystemTools::Error("Could not create generator"); |
| return -1; |
| } |
| } |
| |
| const char* genName = this->CacheManager->GetCacheValue("CMAKE_GENERATOR"); |
| if(genName) |
| { |
| if(strcmp(this->GlobalGenerator->GetName(), genName) != 0) |
| { |
| std::string message = "Error: generator : "; |
| message += this->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(!this->CacheManager->GetCacheValue("CMAKE_GENERATOR")) |
| { |
| this->CacheManager->AddCacheEntry("CMAKE_GENERATOR", |
| this->GlobalGenerator->GetName(), |
| "Name of generator.", |
| cmCacheManager::INTERNAL); |
| } |
| |
| // reset any system configuration information, except for when we are |
| // InTryCompile. With TryCompile the system info is taken from the parent's |
| // info to save time |
| if (!this->InTryCompile) |
| { |
| this->GlobalGenerator->ClearEnabledLanguages(); |
| } |
| |
| this->CleanupWrittenFiles(); |
| |
| // Truncate log files |
| if (!this->InTryCompile) |
| { |
| this->TruncateOutputLog("CMakeOutput.log"); |
| this->TruncateOutputLog("CMakeError.log"); |
| } |
| |
| // actually do the configure |
| this->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(!this->CacheManager->GetCacheValue("LIBRARY_OUTPUT_PATH")) |
| { |
| this->CacheManager->AddCacheEntry |
| ("LIBRARY_OUTPUT_PATH", "", |
| "Single output directory for building all libraries.", |
| cmCacheManager::PATH); |
| } |
| if(!this->CacheManager->GetCacheValue("EXECUTABLE_OUTPUT_PATH")) |
| { |
| this->CacheManager->AddCacheEntry |
| ("EXECUTABLE_OUTPUT_PATH", "", |
| "Single output directory for building all executables.", |
| cmCacheManager::PATH); |
| } |
| if(!this->CacheManager->GetCacheValue("CMAKE_USE_RELATIVE_PATHS")) |
| { |
| this->CacheManager->AddCacheEntry |
| ("CMAKE_USE_RELATIVE_PATHS", false, |
| "If true, cmake will use relative paths in makefiles and projects."); |
| cmCacheManager::CacheIterator it = |
| this->CacheManager->GetCacheIterator("CMAKE_USE_RELATIVE_PATHS"); |
| if ( !it.PropertyExists("ADVANCED") ) |
| { |
| it.SetProperty("ADVANCED", "1"); |
| } |
| } |
| |
| if(cmSystemTools::GetFatalErrorOccured() && |
| (!this->CacheManager->GetCacheValue("CMAKE_MAKE_PROGRAM") || |
| cmSystemTools::IsOff(this->CacheManager-> |
| GetCacheValue("CMAKE_MAKE_PROGRAM")))) |
| { |
| // We must have a bad generator selection. Wipe the cache entry so the |
| // user can select another. |
| this->CacheManager->RemoveCacheEntry("CMAKE_GENERATOR"); |
| } |
| // only save the cache if there were no fatal errors |
| if ( !this->ScriptMode && !cmSystemTools::GetFatalErrorOccured() ) |
| { |
| this->CacheManager->SaveCache(this->GetHomeOutputDirectory()); |
| } |
| if ( !this->GraphVizFile.empty() ) |
| { |
| std::cout << "Generate graphviz: " << this->GraphVizFile << std::endl; |
| this->GenerateGraphViz(this->GraphVizFile.c_str()); |
| } |
| if(cmSystemTools::GetErrorOccuredFlag()) |
| { |
| return -1; |
| } |
| return 0; |
| } |
| |
| bool cmake::CacheVersionMatches() |
| { |
| const char* majv = |
| this->CacheManager->GetCacheValue("CMAKE_CACHE_MAJOR_VERSION"); |
| const char* minv = |
| this->CacheManager->GetCacheValue("CMAKE_CACHE_MINOR_VERSION"); |
| const char* relv = |
| this->CacheManager->GetCacheValue("CMAKE_CACHE_RELEASE_VERSION"); |
| bool cacheSameCMake = false; |
| if(majv && |
| atoi(majv) == static_cast<int>(cmMakefile::GetMajorVersion()) |
| && minv && |
| atoi(minv) == static_cast<int>(cmMakefile::GetMinorVersion()) |
| && relv && (strcmp(relv, cmMakefile::GetReleaseVersion()) == 0)) |
| { |
| cacheSameCMake = true; |
| } |
| return cacheSameCMake; |
| } |
| |
| void cmake::PreLoadCMakeFiles() |
| { |
| std::string pre_load = this->GetHomeDirectory(); |
| if ( pre_load.size() > 0 ) |
| { |
| pre_load += "/PreLoad.cmake"; |
| if ( cmSystemTools::FileExists(pre_load.c_str()) ) |
| { |
| this->ReadListFile(pre_load.c_str()); |
| } |
| } |
| pre_load = this->GetHomeOutputDirectory(); |
| if ( pre_load.size() > 0 ) |
| { |
| pre_load += "/PreLoad.cmake"; |
| if ( cmSystemTools::FileExists(pre_load.c_str()) ) |
| { |
| this->ReadListFile(pre_load.c_str()); |
| } |
| } |
| } |
| |
| // handle a command line invocation |
| int cmake::Run(const std::vector<std::string>& args, bool noconfigure) |
| { |
| // Process the arguments |
| this->SetArgs(args); |
| if(cmSystemTools::GetErrorOccuredFlag()) |
| { |
| CMakeCommandUsage(args[0].c_str()); |
| return -1; |
| } |
| |
| // set the cmake command |
| this->CMakeCommand = args[0]; |
| |
| if ( !this->ScriptMode ) |
| { |
| // load the cache |
| if(this->LoadCache() < 0) |
| { |
| cmSystemTools::Error("Error executing cmake::LoadCache(). Aborting.\n"); |
| return -1; |
| } |
| } |
| else |
| { |
| this->AddCMakePaths(this->CMakeCommand.c_str()); |
| } |
| |
| // Add any cache args |
| if ( !this->SetCacheArgs(args) ) |
| { |
| cmSystemTools::Error("Problem processing arguments. Aborting.\n"); |
| return -1; |
| } |
| |
| // In script mode we terminate after running the script. |
| if(this->ScriptMode) |
| { |
| if(cmSystemTools::GetErrorOccuredFlag()) |
| { |
| return -1; |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| this->PreLoadCMakeFiles(); |
| |
| std::string systemFile = this->GetHomeOutputDirectory(); |
| systemFile += "/CMakeSystem.cmake"; |
| |
| if ( noconfigure ) |
| { |
| return 0; |
| } |
| |
| // now run the global generate |
| // Check the state of the build system to see if we need to regenerate. |
| if(!this->CheckBuildSystem()) |
| { |
| return 0; |
| } |
| |
| // If we are doing global generate, we better set start and start |
| // output directory to the root of the project. |
| std::string oldstartdir = this->GetStartDirectory(); |
| std::string oldstartoutputdir = this->GetStartOutputDirectory(); |
| this->SetStartDirectory(this->GetHomeDirectory()); |
| this->SetStartOutputDirectory(this->GetHomeOutputDirectory()); |
| int ret = this->Configure(); |
| if (ret || this->ScriptMode) |
| { |
| return ret; |
| } |
| ret = this->Generate(); |
| std::string message = "Build files have been written to: "; |
| message += this->GetHomeOutputDirectory(); |
| this->UpdateProgress(message.c_str(), -1); |
| if(ret) |
| { |
| return ret; |
| } |
| this->SetStartDirectory(oldstartdir.c_str()); |
| this->SetStartOutputDirectory(oldstartoutputdir.c_str()); |
| |
| return ret; |
| } |
| |
| int cmake::Generate() |
| { |
| if(!this->GlobalGenerator) |
| { |
| return -1; |
| } |
| this->GlobalGenerator->Generate(); |
| 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(); |
| } |
| |
| void cmake::AddCacheEntry(const char* key, const char* value, |
| const char* helpString, |
| int type) |
| { |
| this->CacheManager->AddCacheEntry(key, value, |
| helpString, |
| cmCacheManager::CacheEntryType(type)); |
| } |
| |
| const char* cmake::GetCacheDefinition(const char* name) const |
| { |
| return this->CacheManager->GetCacheValue(name); |
| } |
| |
| int cmake::DumpDocumentationToFile(std::ostream& f) |
| { |
| #ifdef CMAKE_BUILD_WITH_CMAKE |
| // Loop over all registered commands and print out documentation |
| const char *name; |
| const char *terse; |
| const char *full; |
| char tmp[1024]; |
| sprintf(tmp,"Version %d.%d (%s)", cmake::GetMajorVersion(), |
| cmake::GetMinorVersion(), cmVersion::GetReleaseVersion().c_str()); |
| f << "<html>\n"; |
| f << "<h1>Documentation for commands of CMake " << tmp << "</h1>\n"; |
| f << "<ul>\n"; |
| for(RegisteredCommandsMap::iterator j = this->Commands.begin(); |
| j != this->Commands.end(); ++j) |
| { |
| name = (*j).second->GetName(); |
| terse = (*j).second->GetTerseDocumentation(); |
| full = (*j).second->GetFullDocumentation(); |
| f << "<li><b>" << name << "</b> - " << terse << std::endl |
| << "<br><i>Usage:</i> " << full << "</li>" << std::endl << std::endl; |
| } |
| f << "</ul></html>\n"; |
| #else |
| (void)f; |
| #endif |
| return 1; |
| } |
| |
| void cmake::AddDefaultCommands() |
| { |
| std::list<cmCommand*> commands; |
| GetBootstrapCommands(commands); |
| GetPredefinedCommands(commands); |
| for(std::list<cmCommand*>::iterator i = commands.begin(); |
| i != commands.end(); ++i) |
| { |
| this->AddCommand(*i); |
| } |
| } |
| |
| void cmake::AddDefaultGenerators() |
| { |
| #if defined(_WIN32) && !defined(__CYGWIN__) |
| # if !defined(CMAKE_BOOT_MINGW) |
| this->Generators[cmGlobalVisualStudio6Generator::GetActualName()] = |
| &cmGlobalVisualStudio6Generator::New; |
| this->Generators[cmGlobalVisualStudio7Generator::GetActualName()] = |
| &cmGlobalVisualStudio7Generator::New; |
| this->Generators[cmGlobalVisualStudio71Generator::GetActualName()] = |
| &cmGlobalVisualStudio71Generator::New; |
| this->Generators[cmGlobalVisualStudio8Generator::GetActualName()] = |
| &cmGlobalVisualStudio8Generator::New; |
| this->Generators[cmGlobalVisualStudio8Win64Generator::GetActualName()] = |
| &cmGlobalVisualStudio8Win64Generator::New; |
| this->Generators[cmGlobalBorlandMakefileGenerator::GetActualName()] = |
| &cmGlobalBorlandMakefileGenerator::New; |
| this->Generators[cmGlobalNMakeMakefileGenerator::GetActualName()] = |
| &cmGlobalNMakeMakefileGenerator::New; |
| this->Generators[cmGlobalWatcomWMakeGenerator::GetActualName()] = |
| &cmGlobalWatcomWMakeGenerator::New; |
| # endif |
| this->Generators[cmGlobalMSYSMakefileGenerator::GetActualName()] = |
| &cmGlobalMSYSMakefileGenerator::New; |
| this->Generators[cmGlobalMinGWMakefileGenerator::GetActualName()] = |
| &cmGlobalMinGWMakefileGenerator::New; |
| #endif |
| this->Generators[cmGlobalUnixMakefileGenerator3::GetActualName()] = |
| &cmGlobalUnixMakefileGenerator3::New; |
| #ifdef CMAKE_USE_XCODE |
| this->Generators[cmGlobalXCodeGenerator::GetActualName()] = |
| &cmGlobalXCodeGenerator::New; |
| #endif |
| #ifdef CMAKE_USE_KDEVELOP |
| this->Generators[cmGlobalKdevelopGenerator::GetActualName()] = |
| &cmGlobalKdevelopGenerator::New; |
| #endif |
| } |
| |
| int cmake::LoadCache() |
| { |
| // could we not read the cache |
| if (!this->CacheManager->LoadCache(this->GetHomeOutputDirectory())) |
| { |
| // if it does exist, but isn;t readable then warn the user |
| std::string cacheFile = this->GetHomeOutputDirectory(); |
| cacheFile += "/CMakeCache.txt"; |
| if(cmSystemTools::FileExists(cacheFile.c_str())) |
| { |
| cmSystemTools::Error( |
| "There is a CMakeCache.txt file for the current binary tree but " |
| "cmake does not have permission to read it. Please check the " |
| "permissions of the directory you are trying to run CMake on."); |
| return -1; |
| } |
| } |
| |
| 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(this->CMakeCommand.c_str())) |
| { |
| return -3; |
| } |
| |
| // set the default BACKWARDS compatibility to the current version |
| if(!this->CacheManager->GetCacheValue("CMAKE_BACKWARDS_COMPATIBILITY")) |
| { |
| char ver[256]; |
| sprintf(ver,"%i.%i",cmMakefile::GetMajorVersion(), |
| cmMakefile::GetMinorVersion()); |
| this->CacheManager->AddCacheEntry |
| ("CMAKE_BACKWARDS_COMPATIBILITY",ver, |
| "For backwards compatibility, what version of CMake commands and " |
| "syntax should this version of CMake allow.", |
| cmCacheManager::STRING); |
| } |
| |
| return 0; |
| } |
| |
| void cmake::SetProgressCallback(ProgressCallbackType f, void *cd) |
| { |
| this->ProgressCallback = f; |
| this->ProgressCallbackClientData = cd; |
| } |
| |
| void cmake::UpdateProgress(const char *msg, float prog) |
| { |
| if(this->ProgressCallback && !this->InTryCompile) |
| { |
| (*this->ProgressCallback)(msg, prog, this->ProgressCallbackClientData); |
| return; |
| } |
| } |
| |
| void cmake::GetCommandDocumentation( |
| std::vector<cmDocumentationEntry>& v) const |
| { |
| for(RegisteredCommandsMap::const_iterator j = this->Commands.begin(); |
| j != this->Commands.end(); ++j) |
| { |
| cmDocumentationEntry e = |
| { |
| (*j).second->GetName(), |
| (*j).second->GetTerseDocumentation(), |
| (*j).second->GetFullDocumentation() |
| }; |
| v.push_back(e); |
| } |
| cmDocumentationEntry empty = {0,0,0}; |
| v.push_back(empty); |
| } |
| |
| void cmake::GetGeneratorDocumentation(std::vector<cmDocumentationEntry>& v) |
| { |
| for(RegisteredGeneratorsMap::const_iterator i = this->Generators.begin(); |
| i != this->Generators.end(); ++i) |
| { |
| cmDocumentationEntry e; |
| cmGlobalGenerator* generator = (i->second)(); |
| generator->GetDocumentation(e); |
| delete generator; |
| v.push_back(e); |
| } |
| cmDocumentationEntry empty = {0,0,0}; |
| v.push_back(empty); |
| } |
| |
| void cmake::AddWrittenFile(const char* file) |
| { |
| this->WrittenFiles.insert(file); |
| } |
| |
| bool cmake::HasWrittenFile(const char* file) |
| { |
| return this->WrittenFiles.find(file) != this->WrittenFiles.end(); |
| } |
| |
| void cmake::CleanupWrittenFiles() |
| { |
| this->WrittenFiles.clear(); |
| } |
| |
| void cmake::UpdateConversionPathTable() |
| { |
| // Update the path conversion table with any specified file: |
| const char* tablepath = |
| this->CacheManager->GetCacheValue("CMAKE_PATH_TRANSLATION_FILE"); |
| |
| if(tablepath) |
| { |
| std::ifstream table( tablepath ); |
| if(!table) |
| { |
| cmSystemTools::Error("CMAKE_PATH_TRANSLATION_FILE set to ", tablepath, |
| ". CMake can not open file."); |
| cmSystemTools::ReportLastSystemError("CMake can not open file."); |
| } |
| else |
| { |
| std::string a, b; |
| while(!table.eof()) |
| { |
| // two entries per line |
| table >> a; table >> b; |
| cmSystemTools::AddTranslationPath( a.c_str(), b.c_str()); |
| } |
| } |
| } |
| } |
| |
| //---------------------------------------------------------------------------- |
| int cmake::CheckBuildSystem() |
| { |
| // We do not need to rerun CMake. Check dependency integrity. Use |
| // the make system's VERBOSE environment variable to enable verbose |
| // output. |
| bool verbose = cmSystemTools::GetEnv("VERBOSE") != 0; |
| |
| // This method will check the integrity of the build system if the |
| // option was given on the command line. It reads the given file to |
| // determine whether CMake should rerun. If it does rerun then the |
| // generation step will check the integrity of dependencies. If it |
| // does not then we need to check the integrity here. |
| |
| // If no file is provided for the check, we have to rerun. |
| if(this->CheckBuildSystemArgument.size() == 0) |
| { |
| if(verbose) |
| { |
| cmOStringStream msg; |
| msg << "Re-run cmake no build system arguments\n"; |
| cmSystemTools::Stdout(msg.str().c_str()); |
| } |
| return 1; |
| } |
| |
| // If the file provided does not exist, we have to rerun. |
| if(!cmSystemTools::FileExists(this->CheckBuildSystemArgument.c_str())) |
| { |
| if(verbose) |
| { |
| cmOStringStream msg; |
| msg << "Re-run cmake missing file: " |
| << this->CheckBuildSystemArgument.c_str() << "\n"; |
| cmSystemTools::Stdout(msg.str().c_str()); |
| } |
| return 1; |
| } |
| |
| // Read the rerun check file and use it to decide whether to do the |
| // global generate. |
| cmake cm; |
| cmGlobalGenerator gg; |
| gg.SetCMakeInstance(&cm); |
| std::auto_ptr<cmLocalGenerator> lg(gg.CreateLocalGenerator()); |
| lg->SetGlobalGenerator(&gg); |
| cmMakefile* mf = lg->GetMakefile(); |
| if(!mf->ReadListFile(0, this->CheckBuildSystemArgument.c_str()) || |
| cmSystemTools::GetErrorOccuredFlag()) |
| { |
| if(verbose) |
| { |
| cmOStringStream msg; |
| msg << "Re-run cmake error reading : " |
| << this->CheckBuildSystemArgument.c_str() << "\n"; |
| cmSystemTools::Stdout(msg.str().c_str()); |
| } |
| // There was an error reading the file. Just rerun. |
| return 1; |
| } |
| |
| // Get the set of dependencies and outputs. |
| const char* dependsStr = mf->GetDefinition("CMAKE_MAKEFILE_DEPENDS"); |
| const char* outputsStr = mf->GetDefinition("CMAKE_MAKEFILE_OUTPUTS"); |
| if(!dependsStr || !outputsStr) |
| { |
| // Not enough information was provided to do the test. Just rerun. |
| if(verbose) |
| { |
| cmOStringStream msg; |
| msg << "Re-run cmake no CMAKE_MAKEFILE_DEPENDS " |
| "or CMAKE_MAKEFILE_OUTPUTS :\n"; |
| cmSystemTools::Stdout(msg.str().c_str()); |
| } |
| return 1; |
| } |
| std::vector<std::string> depends; |
| std::vector<std::string> outputs; |
| cmSystemTools::ExpandListArgument(dependsStr, depends); |
| cmSystemTools::ExpandListArgument(outputsStr, outputs); |
| |
| // If any output is older than any dependency then rerun. |
| for(std::vector<std::string>::iterator dep = depends.begin(); |
| dep != depends.end(); ++dep) |
| { |
| for(std::vector<std::string>::iterator out = outputs.begin(); |
| out != outputs.end(); ++out) |
| { |
| int result = 0; |
| if(!this->FileComparison->FileTimeCompare(out->c_str(), |
| dep->c_str(), &result) || |
| result < 0) |
| { |
| if(verbose) |
| { |
| cmOStringStream msg; |
| msg << "Re-run cmake file: " << out->c_str() |
| << " older than: " << dep->c_str() << "\n"; |
| cmSystemTools::Stdout(msg.str().c_str()); |
| } |
| return 1; |
| } |
| } |
| } |
| |
| // compute depends based on the generator specified |
| const char* genName = mf->GetDefinition("CMAKE_DEPENDS_GENERATOR"); |
| if (!genName || genName[0] == '\0') |
| { |
| genName = "Unix Makefiles"; |
| } |
| cmGlobalGenerator *ggd = this->CreateGlobalGenerator(genName); |
| if (ggd) |
| { |
| // Check the dependencies in case source files were removed. |
| std::auto_ptr<cmLocalGenerator> lgd(ggd->CreateLocalGenerator()); |
| lgd->SetGlobalGenerator(ggd); |
| lgd->CheckDependencies(mf, verbose, this->ClearBuildSystem); |
| |
| // Check for multiple output pairs. |
| ggd->CheckMultipleOutputs(mf, verbose); |
| } |
| |
| // No need to rerun. |
| return 0; |
| } |
| |
| //---------------------------------------------------------------------------- |
| void cmake::TruncateOutputLog(const char* fname) |
| { |
| std::string fullPath = this->GetHomeOutputDirectory(); |
| fullPath += "/"; |
| fullPath += fname; |
| struct stat st; |
| if ( ::stat(fullPath.c_str(), &st) ) |
| { |
| return; |
| } |
| if ( !this->CacheManager->GetCacheValue("CMAKE_CACHEFILE_DIR") ) |
| { |
| cmSystemTools::RemoveFile(fullPath.c_str()); |
| return; |
| } |
| size_t fsize = st.st_size; |
| const size_t maxFileSize = 50 * 1024; |
| if ( fsize < maxFileSize ) |
| { |
| //TODO: truncate file |
| return; |
| } |
| } |
| |
| inline std::string removeQuotes(const std::string& s) |
| { |
| if(s[0] == '\"' && s[s.size()-1] == '\"') |
| { |
| return s.substr(1, s.size()-2); |
| } |
| return s; |
| } |
| |
| const char* cmake::GetCTestCommand() |
| { |
| if ( !this->CTestCommand.empty() ) |
| { |
| return this->CTestCommand.c_str(); |
| } |
| |
| cmMakefile* mf |
| = this->GetGlobalGenerator()->GetLocalGenerator(0)->GetMakefile(); |
| #ifdef CMAKE_BUILD_WITH_CMAKE |
| this->CTestCommand = mf->GetRequiredDefinition("CMAKE_COMMAND"); |
| this->CTestCommand = removeQuotes(this->CTestCommand); |
| this->CTestCommand = cmSystemTools::GetFilenamePath(this->CTestCommand.c_str()); |
| this->CTestCommand += "/"; |
| this->CTestCommand += "ctest"; |
| this->CTestCommand += cmSystemTools::GetExecutableExtension(); |
| if(!cmSystemTools::FileExists(this->CTestCommand.c_str())) |
| { |
| this->CTestCommand = mf->GetRequiredDefinition("CMAKE_COMMAND"); |
| this->CTestCommand = cmSystemTools::GetFilenamePath(this->CTestCommand.c_str()); |
| this->CTestCommand += "/Debug/"; |
| this->CTestCommand += "ctest"; |
| this->CTestCommand += cmSystemTools::GetExecutableExtension(); |
| } |
| if(!cmSystemTools::FileExists(this->CTestCommand.c_str())) |
| { |
| this->CTestCommand = mf->GetRequiredDefinition("CMAKE_COMMAND"); |
| this->CTestCommand = cmSystemTools::GetFilenamePath(this->CTestCommand.c_str()); |
| this->CTestCommand += "/Release/"; |
| this->CTestCommand += "ctest"; |
| this->CTestCommand += cmSystemTools::GetExecutableExtension(); |
| } |
| #else |
| // Only for bootstrap |
| this->CTestCommand += mf->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH"); |
| this->CTestCommand += "/ctest"; |
| this->CTestCommand += cmSystemTools::GetExecutableExtension(); |
| #endif |
| 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() ) |
| { |
| return this->CPackCommand.c_str(); |
| } |
| |
| cmMakefile* mf |
| = this->GetGlobalGenerator()->GetLocalGenerator(0)->GetMakefile(); |
| |
| #ifdef CMAKE_BUILD_WITH_CMAKE |
| this->CPackCommand = mf->GetRequiredDefinition("CMAKE_COMMAND"); |
| this->CPackCommand = removeQuotes(this->CPackCommand); |
| this->CPackCommand = cmSystemTools::GetFilenamePath(this->CPackCommand.c_str()); |
| this->CPackCommand += "/"; |
| this->CPackCommand += "cpack"; |
| this->CPackCommand += cmSystemTools::GetExecutableExtension(); |
| if(!cmSystemTools::FileExists(this->CPackCommand.c_str())) |
| { |
| this->CPackCommand = mf->GetRequiredDefinition("CMAKE_COMMAND"); |
| this->CPackCommand = cmSystemTools::GetFilenamePath(this->CPackCommand.c_str()); |
| this->CPackCommand += "/Debug/"; |
| this->CPackCommand += "cpack"; |
| this->CPackCommand += cmSystemTools::GetExecutableExtension(); |
| } |
| if(!cmSystemTools::FileExists(this->CPackCommand.c_str())) |
| { |
| this->CPackCommand = mf->GetRequiredDefinition("CMAKE_COMMAND"); |
| this->CPackCommand = cmSystemTools::GetFilenamePath(this->CPackCommand.c_str()); |
| this->CPackCommand += "/Release/"; |
| this->CPackCommand += "cpack"; |
| this->CPackCommand += cmSystemTools::GetExecutableExtension(); |
| } |
| if (!cmSystemTools::FileExists(this->CPackCommand.c_str())) |
| { |
| cmSystemTools::Error("Cannot find the CPack executable"); |
| this->CPackCommand = "CPACK-COMMAND-NOT-FOUND"; |
| } |
| #else |
| // Only for bootstrap |
| this->CPackCommand += mf->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH"); |
| this->CPackCommand += "/cpack"; |
| this->CPackCommand += cmSystemTools::GetExecutableExtension(); |
| #endif |
| return this->CPackCommand.c_str(); |
| } |
| |
| void cmake::GenerateGraphViz(const char* fileName) |
| { |
| cmGeneratedFileStream str(fileName); |
| if ( !str ) |
| { |
| return; |
| } |
| cmake cm; |
| cmGlobalGenerator ggi; |
| ggi.SetCMakeInstance(&cm); |
| std::auto_ptr<cmLocalGenerator> lg(ggi.CreateLocalGenerator()); |
| lg->SetGlobalGenerator(&ggi); |
| cmMakefile *mf = lg->GetMakefile(); |
| |
| std::string infile = this->GetHomeOutputDirectory(); |
| infile += "/CMakeGraphVizOptions.cmake"; |
| if ( !cmSystemTools::FileExists(infile.c_str()) ) |
| { |
| infile = this->GetHomeDirectory(); |
| infile += "/CMakeGraphVizOptions.cmake"; |
| if ( !cmSystemTools::FileExists(infile.c_str()) ) |
| { |
| infile = ""; |
| } |
| } |
| |
| if ( !infile.empty() ) |
| { |
| if ( !mf->ReadListFile(0, infile.c_str()) ) |
| { |
| cmSystemTools::Error("Problem opening GraphViz options file: ", |
| infile.c_str()); |
| return; |
| } |
| std::cout << "Read GraphViz options file: " << infile.c_str() |
| << std::endl; |
| } |
| |
| #define __set_if_not_set(var, value, cmakeDefinition) \ |
| const char* var = mf->GetDefinition(cmakeDefinition); \ |
| if ( !var ) \ |
| { \ |
| var = value; \ |
| } |
| __set_if_not_set(graphType, "digraph", "GRAPHVIZ_GRAPH_TYPE"); |
| __set_if_not_set(graphName, "GG", "GRAPHVIZ_GRAPH_NAME"); |
| __set_if_not_set(graphHeader, "node [\n fontsize = \"12\"\n];", |
| "GRAPHVIZ_GRAPH_HEADER"); |
| __set_if_not_set(graphNodePrefix, "node", "GRAPHVIZ_NODE_PREFIX"); |
| const char* ignoreTargets = mf->GetDefinition("GRAPHVIZ_IGNORE_TARGETS"); |
| std::set<cmStdString> ignoreTargetsSet; |
| if ( ignoreTargets ) |
| { |
| std::vector<std::string> ignoreTargetsVector; |
| cmSystemTools::ExpandListArgument(ignoreTargets,ignoreTargetsVector); |
| std::vector<std::string>::iterator itvIt; |
| for ( itvIt = ignoreTargetsVector.begin(); |
| itvIt != ignoreTargetsVector.end(); |
| ++ itvIt ) |
| { |
| ignoreTargetsSet.insert(itvIt->c_str()); |
| } |
| } |
| |
| str << graphType << " " << graphName << " {" << std::endl; |
| str << graphHeader << std::endl; |
| |
| cmGlobalGenerator* gg = this->GetGlobalGenerator(); |
| std::vector<cmLocalGenerator*> localGenerators; |
| gg->GetLocalGenerators(localGenerators); |
| std::vector<cmLocalGenerator*>::iterator lit; |
| // for target deps |
| // 1 - cmake target |
| // 2 - external target |
| // 0 - no deps |
| std::map<cmStdString, int> targetDeps; |
| std::map<cmStdString, cmTarget*> targetPtrs; |
| std::map<cmStdString, cmStdString> targetNamesNodes; |
| char tgtName[100]; |
| int cnt = 0; |
| // First pass get the list of all cmake targets |
| for ( lit = localGenerators.begin(); lit != localGenerators.end(); ++ lit ) |
| { |
| cmTargets* targets = &((*lit)->GetMakefile()->GetTargets()); |
| cmTargets::iterator tit; |
| for ( tit = targets->begin(); tit != targets->end(); ++ tit ) |
| { |
| const char* realTargetName = tit->first.c_str(); |
| if ( ignoreTargetsSet.find(realTargetName) != ignoreTargetsSet.end() ) |
| { |
| // Skip ignored targets |
| continue; |
| } |
| //std::cout << "Found target: " << tit->first.c_str() << std::endl; |
| sprintf(tgtName, "%s%d", graphNodePrefix, cnt++); |
| targetNamesNodes[realTargetName] = tgtName; |
| targetPtrs[realTargetName] = &tit->second; |
| //str << " \"" << tgtName << "\" [ label=\"" << tit->first.c_str() |
| //<< "\" shape=\"box\"];" << std::endl; |
| } |
| } |
| // Ok, now find all the stuff we link to that is not in cmake |
| for ( lit = localGenerators.begin(); lit != localGenerators.end(); ++ lit ) |
| { |
| cmTargets* targets = &((*lit)->GetMakefile()->GetTargets()); |
| cmTargets::iterator tit; |
| for ( tit = targets->begin(); tit != targets->end(); ++ tit ) |
| { |
| const cmTarget::LinkLibraryVectorType* ll |
| = &(tit->second.GetOriginalLinkLibraries()); |
| cmTarget::LinkLibraryVectorType::const_iterator llit; |
| const char* realTargetName = tit->first.c_str(); |
| if ( ignoreTargetsSet.find(realTargetName) != ignoreTargetsSet.end() ) |
| { |
| // Skip ignored targets |
| continue; |
| } |
| if ( ll->size() > 0 ) |
| { |
| targetDeps[realTargetName] = 1; |
| } |
| for ( llit = ll->begin(); llit != ll->end(); ++ llit ) |
| { |
| const char* libName = llit->first.c_str(); |
| std::map<cmStdString, cmStdString>::iterator tarIt |
| = targetNamesNodes.find(libName); |
| if ( ignoreTargetsSet.find(libName) != ignoreTargetsSet.end() ) |
| { |
| // Skip ignored targets |
| continue; |
| } |
| if ( tarIt == targetNamesNodes.end() ) |
| { |
| sprintf(tgtName, "%s%d", graphNodePrefix, cnt++); |
| targetDeps[libName] = 2; |
| targetNamesNodes[libName] = tgtName; |
| //str << " \"" << tgtName << "\" [ label=\"" << libName |
| //<< "\" shape=\"ellipse\"];" << std::endl; |
| } |
| else |
| { |
| std::map<cmStdString, int>::iterator depIt |
| = targetDeps.find(libName); |
| if ( depIt == targetDeps.end() ) |
| { |
| targetDeps[libName] = 1; |
| } |
| } |
| } |
| } |
| } |
| |
| // Write out nodes |
| std::map<cmStdString, int>::iterator depIt; |
| for ( depIt = targetDeps.begin(); depIt != targetDeps.end(); ++ depIt ) |
| { |
| const char* newTargetName = depIt->first.c_str(); |
| std::map<cmStdString, cmStdString>::iterator tarIt |
| = targetNamesNodes.find(newTargetName); |
| if ( tarIt == targetNamesNodes.end() ) |
| { |
| // We should not be here. |
| std::cout << __LINE__ << " Cannot find library: " << newTargetName |
| << " even though it was added in the previous pass" << std::endl; |
| abort(); |
| } |
| |
| str << " \"" << tarIt->second.c_str() << "\" [ label=\"" |
| << newTargetName << "\" shape=\""; |
| if ( depIt->second == 1 ) |
| { |
| std::map<cmStdString, cmTarget*>::iterator tarTypeIt= targetPtrs.find( |
| newTargetName); |
| if ( tarTypeIt == targetPtrs.end() ) |
| { |
| // We should not be here. |
| std::cout << __LINE__ << " Cannot find library: " << newTargetName |
| << " even though it was added in the previous pass" << std::endl; |
| abort(); |
| } |
| cmTarget* tg = tarTypeIt->second; |
| switch ( tg->GetType() ) |
| { |
| case cmTarget::EXECUTABLE: |
| str << "house"; |
| break; |
| case cmTarget::STATIC_LIBRARY: |
| str << "diamond"; |
| break; |
| case cmTarget::SHARED_LIBRARY: |
| str << "polygon"; |
| break; |
| case cmTarget::MODULE_LIBRARY: |
| str << "octagon"; |
| break; |
| default: |
| str << "box"; |
| } |
| } |
| else |
| { |
| str << "ellipse"; |
| } |
| str << "\"];" << std::endl; |
| } |
| |
| // Now generate the connectivity |
| for ( lit = localGenerators.begin(); lit != localGenerators.end(); ++ lit ) |
| { |
| cmTargets* targets = &((*lit)->GetMakefile()->GetTargets()); |
| cmTargets::iterator tit; |
| for ( tit = targets->begin(); tit != targets->end(); ++ tit ) |
| { |
| std::map<cmStdString, int>::iterator dependIt |
| = targetDeps.find(tit->first.c_str()); |
| if ( dependIt == targetDeps.end() ) |
| { |
| continue; |
| } |
| std::map<cmStdString, cmStdString>::iterator cmakeTarIt |
| = targetNamesNodes.find(tit->first.c_str()); |
| const cmTarget::LinkLibraryVectorType* ll |
| = &(tit->second.GetOriginalLinkLibraries()); |
| cmTarget::LinkLibraryVectorType::const_iterator llit; |
| for ( llit = ll->begin(); llit != ll->end(); ++ llit ) |
| { |
| const char* libName = llit->first.c_str(); |
| std::map<cmStdString, cmStdString>::iterator tarIt |
| = targetNamesNodes.find(libName); |
| if ( tarIt == targetNamesNodes.end() ) |
| { |
| // We should not be here. |
| std::cout << __LINE__ << " Cannot find library: " << libName |
| << " even though it was added in the previous pass" << std::endl; |
| abort(); |
| } |
| str << " \"" << cmakeTarIt->second.c_str() << "\" -> \"" |
| << tarIt->second.c_str() << "\"" << std::endl; |
| } |
| } |
| } |
| |
| // TODO: Use dotted or something for external libraries |
| //str << " \"node0\":f4 -> \"node12\"[color=\"#0000ff\" style=dotted]" |
| //<< std::endl; |
| // |
| str << "}" << std::endl; |
| } |
| |
