| /*========================================================================= |
| |
| 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 "cmGlobalGenerator.h" |
| #include "cmLocalGenerator.h" |
| #include "cmake.h" |
| #include "cmMakefile.h" |
| |
| #include <stdlib.h> // required for atof |
| |
| #if defined(_WIN32) && !defined(__CYGWIN__) |
| #include <windows.h> |
| #endif |
| |
| #include <assert.h> |
| |
| int cmGlobalGenerator::s_TryCompileTimeout = 0; |
| |
| cmGlobalGenerator::cmGlobalGenerator() |
| { |
| // By default the .SYMBOLIC dependency is not needed on symbolic rules. |
| this->NeedSymbolicMark = false; |
| |
| // by default use the native paths |
| this->ForceUnixPaths = false; |
| |
| // By default do not try to support color. |
| this->ToolSupportsColor = false; |
| |
| // By default do not use link scripts. |
| this->UseLinkScript = false; |
| |
| // Relative paths are not configured in the constructor. |
| this->RelativePathsConfigured = false; |
| |
| // Whether an install target is needed. |
| this->InstallTargetEnabled = false; |
| } |
| |
| cmGlobalGenerator::~cmGlobalGenerator() |
| { |
| // Delete any existing cmLocalGenerators |
| unsigned int i; |
| for (i = 0; i < this->LocalGenerators.size(); ++i) |
| { |
| delete this->LocalGenerators[i]; |
| } |
| this->LocalGenerators.clear(); |
| } |
| |
| // Find the make program for the generator, required for try compiles |
| void cmGlobalGenerator::FindMakeProgram(cmMakefile* mf) |
| { |
| if(this->FindMakeProgramFile.size() == 0) |
| { |
| cmSystemTools::Error( |
| "Generator implementation error, " |
| "all generators must specify this->FindMakeProgramFile"); |
| } |
| if(!mf->GetDefinition("CMAKE_MAKE_PROGRAM") |
| || cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) |
| { |
| std::string setMakeProgram = |
| mf->GetModulesFile(this->FindMakeProgramFile.c_str()); |
| if(setMakeProgram.size()) |
| { |
| mf->ReadListFile(0, setMakeProgram.c_str()); |
| } |
| } |
| if(!mf->GetDefinition("CMAKE_MAKE_PROGRAM") |
| || cmSystemTools::IsOff(mf->GetDefinition("CMAKE_MAKE_PROGRAM"))) |
| { |
| cmOStringStream err; |
| err << "CMake was unable to find a build program corresponding to \"" |
| << this->GetName() << "\". CMAKE_MAKE_PROGRAM is not set. You " |
| << "probably need to select a different build tool."; |
| cmSystemTools::Error(err.str().c_str()); |
| cmSystemTools::SetFatalErrorOccured(); |
| return; |
| } |
| std::string makeProgram = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM"); |
| // if there are spaces in the make program use short path |
| // but do not short path the actual program name, as |
| // this can cause trouble with VSExpress |
| if(makeProgram.find(' ') != makeProgram.npos) |
| { |
| std::string dir; |
| std::string file; |
| cmSystemTools::SplitProgramPath(makeProgram.c_str(), |
| dir, file); |
| std::string saveFile = file; |
| cmSystemTools::GetShortPath(makeProgram.c_str(), makeProgram); |
| cmSystemTools::SplitProgramPath(makeProgram.c_str(), |
| dir, file); |
| makeProgram = dir; |
| makeProgram += "/"; |
| makeProgram += saveFile; |
| mf->AddCacheDefinition("CMAKE_MAKE_PROGRAM", makeProgram.c_str(), |
| "make program", |
| cmCacheManager::FILEPATH); |
| } |
| |
| if(makeProgram.find("xcodebuild") != makeProgram.npos) |
| { |
| // due to the text file busy /bin/sh problem with xcodebuild |
| // use the cmakexbuild wrapper instead. This program |
| // will run xcodebuild and if it sees the error text file busy |
| // it will stop forwarding output, and let the build finish. |
| // Then it will retry the build. It will continue this |
| // untill no text file busy errors occur. |
| std::string cmakexbuild = |
| this->CMakeInstance->GetCacheManager()->GetCacheValue("CMAKE_COMMAND"); |
| cmakexbuild = cmakexbuild.substr(0, cmakexbuild.length()-5); |
| cmakexbuild += "cmakexbuild"; |
| |
| mf->AddCacheDefinition("CMAKE_MAKE_PROGRAM", |
| cmakexbuild.c_str(), |
| "make program", |
| cmCacheManager::FILEPATH); |
| } |
| } |
| |
| // enable the given language |
| // |
| // The following files are loaded in this order: |
| // |
| // First figure out what OS we are running on: |
| // |
| // CMakeSystem.cmake - configured file created by CMakeDetermineSystem.cmake |
| // CMakeDetermineSystem.cmake - figure out os info and create |
| // CMakeSystem.cmake IFF CMAKE_SYSTEM_NAME |
| // not set |
| // CMakeSystem.cmake - configured file created by |
| // CMakeDetermineSystem.cmake IFF CMAKE_SYSTEM_LOADED |
| |
| // Next try and enable all languages found in the languages vector |
| // |
| // FOREACH LANG in languages |
| // CMake(LANG)Compiler.cmake - configured file create by |
| // CMakeDetermine(LANG)Compiler.cmake |
| // CMakeDetermine(LANG)Compiler.cmake - Finds compiler for LANG and |
| // creates CMake(LANG)Compiler.cmake |
| // CMake(LANG)Compiler.cmake - configured file created by |
| // CMakeDetermine(LANG)Compiler.cmake |
| // |
| // CMakeSystemSpecificInformation.cmake |
| // - includes Platform/${CMAKE_SYSTEM_NAME}.cmake |
| // may use compiler stuff |
| |
| // FOREACH LANG in languages |
| // CMake(LANG)Information.cmake |
| // - loads Platform/${CMAKE_SYSTEM_NAME}-${COMPILER}.cmake |
| // CMakeTest(LANG)Compiler.cmake |
| // - Make sure the compiler works with a try compile if |
| // CMakeDetermine(LANG) was loaded |
| // |
| // Now load a few files that can override values set in any of the above |
| // CMake(PROJECTNAME)Compatibility.cmake |
| // - load any backwards compatibility stuff for current project |
| // ${CMAKE_USER_MAKE_RULES_OVERRIDE} |
| // - allow users a chance to override system variables |
| // |
| // |
| |
| void |
| cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages, |
| cmMakefile *mf) |
| { |
| if(languages.size() == 0) |
| { |
| cmSystemTools::Error("EnableLanguage must have a lang specified!"); |
| cmSystemTools::SetFatalErrorOccured(); |
| return; |
| } |
| mf->AddDefinition("RUN_CONFIGURE", true); |
| std::string rootBin = mf->GetHomeOutputDirectory(); |
| rootBin += cmake::GetCMakeFilesDirectory(); |
| |
| // If the configuration files path has been set, |
| // then we are in a try compile and need to copy the enable language |
| // files from the parent cmake bin dir, into the try compile bin dir |
| if(this->ConfiguredFilesPath.size()) |
| { |
| for(std::vector<std::string>::const_iterator l = languages.begin(); |
| l != languages.end(); ++l) |
| { |
| if(*l == "NONE") |
| { |
| this->SetLanguageEnabled("NONE", mf); |
| break; |
| } |
| } |
| rootBin = this->ConfiguredFilesPath; |
| } |
| |
| // set the dir for parent files so they can be used by modules |
| mf->AddDefinition("CMAKE_PLATFORM_ROOT_BIN",rootBin.c_str()); |
| |
| // find and make sure CMAKE_MAKE_PROGRAM is defined |
| this->FindMakeProgram(mf); |
| |
| // try and load the CMakeSystem.cmake if it is there |
| std::string fpath = rootBin; |
| if(!mf->GetDefinition("CMAKE_SYSTEM_LOADED")) |
| { |
| fpath += "/CMakeSystem.cmake"; |
| if(cmSystemTools::FileExists(fpath.c_str())) |
| { |
| mf->ReadListFile(0,fpath.c_str()); |
| } |
| } |
| // Load the CMakeDetermineSystem.cmake file and find out |
| // what platform we are running on |
| if (!mf->GetDefinition("CMAKE_SYSTEM_NAME")) |
| { |
| #if defined(_WIN32) && !defined(__CYGWIN__) |
| /* Windows version number data. */ |
| OSVERSIONINFO osvi; |
| ZeroMemory(&osvi, sizeof(osvi)); |
| osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); |
| GetVersionEx (&osvi); |
| cmOStringStream windowsVersionString; |
| windowsVersionString << osvi.dwMajorVersion << "." << osvi.dwMinorVersion; |
| windowsVersionString.str(); |
| mf->AddDefinition("CMAKE_SYSTEM_VERSION", |
| windowsVersionString.str().c_str()); |
| #endif |
| // Read the DetermineSystem file |
| std::string systemFile = mf->GetModulesFile("CMakeDetermineSystem.cmake"); |
| mf->ReadListFile(0, systemFile.c_str()); |
| // load the CMakeSystem.cmake from the binary directory |
| // this file is configured by the CMakeDetermineSystem.cmake file |
| fpath = rootBin; |
| fpath += "/CMakeSystem.cmake"; |
| mf->ReadListFile(0,fpath.c_str()); |
| } |
| std::map<cmStdString, bool> needTestLanguage; |
| // foreach language |
| // load the CMakeDetermine(LANG)Compiler.cmake file to find |
| // the compiler |
| |
| for(std::vector<std::string>::const_iterator l = languages.begin(); |
| l != languages.end(); ++l) |
| { |
| const char* lang = l->c_str(); |
| if(*l == "NONE") |
| { |
| this->SetLanguageEnabled("NONE", mf); |
| continue; |
| } |
| bool determineLanguageCalled = false; |
| std::string loadedLang = "CMAKE_"; |
| loadedLang += lang; |
| loadedLang += "_COMPILER_LOADED"; |
| // If the existing build tree was already configured with this |
| // version of CMake then try to load the configured file first |
| // to avoid duplicate compiler tests. |
| unsigned int cacheMajor = mf->GetCacheMajorVersion(); |
| unsigned int cacheMinor = mf->GetCacheMinorVersion(); |
| unsigned int selfMajor = cmMakefile::GetMajorVersion(); |
| unsigned int selfMinor = cmMakefile::GetMinorVersion(); |
| if((this->CMakeInstance->GetIsInTryCompile() || |
| (selfMajor == cacheMajor && selfMinor == cacheMinor)) |
| && !mf->GetDefinition(loadedLang.c_str())) |
| { |
| fpath = rootBin; |
| fpath += "/CMake"; |
| fpath += lang; |
| fpath += "Compiler.cmake"; |
| if(cmSystemTools::FileExists(fpath.c_str())) |
| { |
| if(!mf->ReadListFile(0,fpath.c_str())) |
| { |
| cmSystemTools::Error("Could not find cmake module file:", |
| fpath.c_str()); |
| } |
| // if this file was found then the language was already determined |
| // to be working |
| needTestLanguage[lang] = false; |
| this->SetLanguageEnabled(lang, mf); |
| // this can only be called after loading CMake(LANG)Compiler.cmake |
| } |
| } |
| |
| if(!this->GetLanguageEnabled(lang) ) |
| { |
| if (this->CMakeInstance->GetIsInTryCompile()) |
| { |
| cmSystemTools::Error("This should not have happen. " |
| "If you see this message, you are probably " |
| "using a broken CMakeLists.txt file or a " |
| "problematic release of CMake"); |
| } |
| // if the CMake(LANG)Compiler.cmake file was not found then |
| // load CMakeDetermine(LANG)Compiler.cmake |
| std::string determineCompiler = "CMakeDetermine"; |
| determineCompiler += lang; |
| determineCompiler += "Compiler.cmake"; |
| std::string determineFile = |
| mf->GetModulesFile(determineCompiler.c_str()); |
| if(!mf->ReadListFile(0,determineFile.c_str())) |
| { |
| cmSystemTools::Error("Could not find cmake module file:", |
| determineFile.c_str()); |
| } |
| needTestLanguage[lang] = true; |
| determineLanguageCalled = true; |
| // Some generators like visual studio should not use the env variables |
| // So the global generator can specify that in this variable |
| if(!mf->GetDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV")) |
| { |
| // put ${CMake_(LANG)_COMPILER_ENV_VAR}=${CMAKE_(LANG)_COMPILER |
| // into the environment, in case user scripts want to run |
| // configure, or sub cmakes |
| std::string compilerName = "CMAKE_"; |
| compilerName += lang; |
| compilerName += "_COMPILER"; |
| std::string compilerEnv = "CMAKE_"; |
| compilerEnv += lang; |
| compilerEnv += "_COMPILER_ENV_VAR"; |
| std::string envVar = mf->GetRequiredDefinition(compilerEnv.c_str()); |
| std::string envVarValue = |
| mf->GetRequiredDefinition(compilerName.c_str()); |
| std::string env = envVar; |
| env += "="; |
| env += envVarValue; |
| cmSystemTools::PutEnv(env.c_str()); |
| } |
| } // end if(!this->GetLanguageEnabled(lang) ) |
| // if determineLanguage was called then load the file it |
| // configures CMake(LANG)Compiler.cmake |
| if(determineLanguageCalled) |
| { |
| fpath = rootBin; |
| fpath += "/CMake"; |
| fpath += lang; |
| fpath += "Compiler.cmake"; |
| if(!mf->ReadListFile(0,fpath.c_str())) |
| { |
| cmSystemTools::Error("Could not find cmake module file:", |
| fpath.c_str()); |
| } |
| this->SetLanguageEnabled(lang, mf); |
| // this can only be called after loading CMake(LANG)Compiler.cmake |
| // the language must be enabled for try compile to work, but we do |
| // not know if it is a working compiler yet so set the test language |
| // flag |
| needTestLanguage[lang] = true; |
| } |
| } // end loop over languages |
| |
| // **** Load the system specific information if not yet loaded |
| if (!mf->GetDefinition("CMAKE_SYSTEM_SPECIFIC_INFORMATION_LOADED")) |
| { |
| fpath = mf->GetModulesFile("CMakeSystemSpecificInformation.cmake"); |
| if(!mf->ReadListFile(0,fpath.c_str())) |
| { |
| cmSystemTools::Error("Could not find cmake module file:", |
| fpath.c_str()); |
| } |
| } |
| // loop over languages again loading CMake(LANG)Information.cmake |
| // |
| for(std::vector<std::string>::const_iterator l = languages.begin(); |
| l != languages.end(); ++l) |
| { |
| const char* lang = l->c_str(); |
| if(*l == "NONE") |
| { |
| this->SetLanguageEnabled("NONE", mf); |
| continue; |
| } |
| std::string langLoadedVar = "CMAKE_"; |
| langLoadedVar += lang; |
| langLoadedVar += "_INFORMATION_LOADED"; |
| if (!mf->GetDefinition(langLoadedVar.c_str())) |
| { |
| fpath = "CMake"; |
| fpath += lang; |
| fpath += "Information.cmake"; |
| fpath = mf->GetModulesFile(fpath.c_str()); |
| if(!mf->ReadListFile(0,fpath.c_str())) |
| { |
| cmSystemTools::Error("Could not find cmake module file:", |
| fpath.c_str()); |
| } |
| } |
| // Test the compiler for the language just setup |
| // At this point we should have enough info for a try compile |
| // which is used in the backward stuff |
| // If the language is untested then test it now with a try compile. |
| if(needTestLanguage[lang]) |
| { |
| if (!this->CMakeInstance->GetIsInTryCompile()) |
| { |
| std::string testLang = "CMakeTest"; |
| testLang += lang; |
| testLang += "Compiler.cmake"; |
| std::string ifpath = mf->GetModulesFile(testLang.c_str()); |
| if(!mf->ReadListFile(0,ifpath.c_str())) |
| { |
| cmSystemTools::Error("Could not find cmake module file:", |
| ifpath.c_str()); |
| } |
| std::string compilerWorks = "CMAKE_"; |
| compilerWorks += lang; |
| compilerWorks += "_COMPILER_WORKS"; |
| // if the compiler did not work, then remove the |
| // CMake(LANG)Compiler.cmake file so that it will get tested the |
| // next time cmake is run |
| if(!mf->IsOn(compilerWorks.c_str())) |
| { |
| fpath = rootBin; |
| fpath += "/CMake"; |
| fpath += lang; |
| fpath += "Compiler.cmake"; |
| cmSystemTools::RemoveFile(fpath.c_str()); |
| } |
| else |
| { |
| // load backwards compatibility stuff for C and CXX |
| // for old versions of CMake ListFiles C and CXX had some |
| // backwards compatibility files they have to load |
| // These files have a bunch of try compiles in them so |
| // should only be done |
| const char* versionValue |
| = mf->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY"); |
| if (atof(versionValue) <= 1.4) |
| { |
| if(strcmp(lang, "C") == 0) |
| { |
| ifpath = |
| mf->GetModulesFile("CMakeBackwardCompatibilityC.cmake"); |
| mf->ReadListFile(0,ifpath.c_str()); |
| } |
| if(strcmp(lang, "CXX") == 0) |
| { |
| ifpath = |
| mf->GetModulesFile("CMakeBackwardCompatibilityCXX.cmake"); |
| mf->ReadListFile(0,ifpath.c_str()); |
| } |
| } |
| } |
| } // end if in try compile |
| } // end need test language |
| } // end for each language |
| |
| // Now load files that can override any settings on the platform or for |
| // the project First load the project compatibility file if it is in |
| // cmake |
| std::string projectCompatibility = mf->GetDefinition("CMAKE_ROOT"); |
| projectCompatibility += "/Modules/"; |
| projectCompatibility += mf->GetSafeDefinition("PROJECT_NAME"); |
| projectCompatibility += "Compatibility.cmake"; |
| if(cmSystemTools::FileExists(projectCompatibility.c_str())) |
| { |
| mf->ReadListFile(0,projectCompatibility.c_str()); |
| } |
| } |
| |
| const char* cmGlobalGenerator |
| ::GetLanguageOutputExtensionForLanguage(const char* lang) |
| { |
| if(!lang) |
| { |
| return ""; |
| } |
| if(this->LanguageToOutputExtension.count(lang) > 0) |
| { |
| return this->LanguageToOutputExtension[lang].c_str(); |
| } |
| return ""; |
| } |
| |
| const char* cmGlobalGenerator |
| ::GetLanguageOutputExtensionFromExtension(const char* ext) |
| { |
| if(!ext) |
| { |
| return ""; |
| } |
| const char* lang = this->GetLanguageFromExtension(ext); |
| if(!lang || *lang == 0) |
| { |
| // if no language is found then check to see if it is already an |
| // ouput extension for some language. In that case it should be ignored |
| // and in this map, so it will not be compiled but will just be used. |
| if(this->OutputExtensions.count(ext)) |
| { |
| return ext; |
| } |
| } |
| return this->GetLanguageOutputExtensionForLanguage(lang); |
| } |
| |
| |
| const char* cmGlobalGenerator::GetLanguageFromExtension(const char* ext) |
| { |
| // if there is an extension and it starts with . then move past the |
| // . because the extensions are not stored with a . in the map |
| if(ext && *ext == '.') |
| { |
| ++ext; |
| } |
| if(this->ExtensionToLanguage.count(ext) > 0) |
| { |
| return this->ExtensionToLanguage[ext].c_str(); |
| } |
| return 0; |
| } |
| |
| void cmGlobalGenerator::SetLanguageEnabled(const char* l, cmMakefile* mf) |
| { |
| if(this->LanguageEnabled.count(l) > 0) |
| { |
| return; |
| } |
| std::string outputExtensionVar = std::string("CMAKE_") + |
| std::string(l) + std::string("_OUTPUT_EXTENSION"); |
| const char* outputExtension = mf->GetDefinition(outputExtensionVar.c_str()); |
| if(outputExtension) |
| { |
| this->LanguageToOutputExtension[l] = outputExtension; |
| this->OutputExtensions[outputExtension] = outputExtension; |
| if(outputExtension[0] == '.') |
| { |
| this->OutputExtensions[outputExtension+1] = outputExtension+1; |
| } |
| } |
| |
| std::string linkerPrefVar = std::string("CMAKE_") + |
| std::string(l) + std::string("_LINKER_PREFERENCE"); |
| const char* linkerPref = mf->GetDefinition(linkerPrefVar.c_str()); |
| if(!linkerPref) |
| { |
| linkerPref = "None"; |
| } |
| this->LanguageToLinkerPreference[l] = linkerPref; |
| |
| std::string extensionsVar = std::string("CMAKE_") + |
| std::string(l) + std::string("_SOURCE_FILE_EXTENSIONS"); |
| std::string ignoreExtensionsVar = std::string("CMAKE_") + |
| std::string(l) + std::string("_IGNORE_EXTENSIONS"); |
| std::string ignoreExts = mf->GetSafeDefinition(ignoreExtensionsVar.c_str()); |
| std::string exts = mf->GetSafeDefinition(extensionsVar.c_str()); |
| std::vector<std::string> extensionList; |
| cmSystemTools::ExpandListArgument(exts, extensionList); |
| for(std::vector<std::string>::iterator i = extensionList.begin(); |
| i != extensionList.end(); ++i) |
| { |
| this->ExtensionToLanguage[*i] = l; |
| } |
| cmSystemTools::ExpandListArgument(ignoreExts, extensionList); |
| for(std::vector<std::string>::iterator i = extensionList.begin(); |
| i != extensionList.end(); ++i) |
| { |
| this->IgnoreExtensions[*i] = true; |
| } |
| this->LanguageEnabled[l] = true; |
| |
| } |
| bool cmGlobalGenerator::IgnoreFile(const char* l) |
| { |
| if(this->GetLanguageFromExtension(l)) |
| { |
| return false; |
| } |
| return (this->IgnoreExtensions.count(l) > 0); |
| } |
| |
| bool cmGlobalGenerator::GetLanguageEnabled(const char* l) |
| { |
| return (this->LanguageEnabled.count(l) > 0); |
| } |
| |
| void cmGlobalGenerator::ClearEnabledLanguages() |
| { |
| this->LanguageEnabled.clear(); |
| } |
| |
| bool cmGlobalGenerator::IsDependedOn(const char* project, |
| cmTarget* targetIn) |
| { |
| // Get all local gens for this project |
| std::vector<cmLocalGenerator*>* gens = &this->ProjectMap[project]; |
| // loop over local gens and get the targets for each one |
| for(unsigned int i = 0; i < gens->size(); ++i) |
| { |
| cmTargets& targets = (*gens)[i]->GetMakefile()->GetTargets(); |
| for (cmTargets::iterator l = targets.begin(); |
| l != targets.end(); l++) |
| { |
| cmTarget& target = l->second; |
| std::set<cmStdString>::const_iterator pos = |
| target.GetUtilities().find(targetIn->GetName()); |
| if(pos != target.GetUtilities().end()) |
| { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| void cmGlobalGenerator::Configure() |
| { |
| // Delete any existing cmLocalGenerators |
| unsigned int i; |
| for (i = 0; i < this->LocalGenerators.size(); ++i) |
| { |
| delete this->LocalGenerators[i]; |
| } |
| this->LocalGenerators.clear(); |
| |
| this->TotalTargets.clear(); |
| |
| // start with this directory |
| cmLocalGenerator *lg = this->CreateLocalGenerator(); |
| this->LocalGenerators.push_back(lg); |
| |
| // set the Start directories |
| lg->GetMakefile()->SetStartDirectory |
| (this->CMakeInstance->GetStartDirectory()); |
| lg->GetMakefile()->SetStartOutputDirectory |
| (this->CMakeInstance->GetStartOutputDirectory()); |
| lg->GetMakefile()->MakeStartDirectoriesCurrent(); |
| |
| // now do it |
| lg->Configure(); |
| |
| // update the cache entry for the number of local generators, this is used |
| // for progress |
| char num[100]; |
| sprintf(num,"%d",static_cast<int>(this->LocalGenerators.size())); |
| this->GetCMakeInstance()->AddCacheEntry |
| ("CMAKE_NUMBER_OF_LOCAL_GENERATORS", num, |
| "number of local generators", cmCacheManager::INTERNAL); |
| |
| std::set<cmStdString> notFoundMap; |
| // after it is all done do a ConfigureFinalPass |
| cmCacheManager* manager = 0; |
| for (i = 0; i < this->LocalGenerators.size(); ++i) |
| { |
| manager = this->LocalGenerators[i]->GetMakefile()->GetCacheManager(); |
| this->LocalGenerators[i]->ConfigureFinalPass(); |
| cmTargets & targets = |
| this->LocalGenerators[i]->GetMakefile()->GetTargets(); |
| for (cmTargets::iterator l = targets.begin(); |
| l != targets.end(); l++) |
| { |
| cmTarget::LinkLibraryVectorType libs = l->second.GetLinkLibraries(); |
| for(cmTarget::LinkLibraryVectorType::iterator lib = libs.begin(); |
| lib != libs.end(); ++lib) |
| { |
| if(lib->first.size() > 9 && |
| cmSystemTools::IsNOTFOUND(lib->first.c_str())) |
| { |
| std::string varName = lib->first.substr(0, lib->first.size()-9); |
| notFoundMap.insert(varName); |
| } |
| } |
| std::vector<std::string>& incs = |
| this->LocalGenerators[i]->GetMakefile()->GetIncludeDirectories(); |
| |
| for( std::vector<std::string>::iterator lib = incs.begin(); |
| lib != incs.end(); ++lib) |
| { |
| if(lib->size() > 9 && |
| cmSystemTools::IsNOTFOUND(lib->c_str())) |
| { |
| std::string varName = lib->substr(0, lib->size()-9); |
| notFoundMap.insert(varName); |
| } |
| } |
| this->CMakeInstance->UpdateProgress |
| ("Configuring", 0.9f+0.1f*(i+1.0f)/this->LocalGenerators.size()); |
| this->LocalGenerators[i]->GetMakefile()->CheckInfiniteLoops(); |
| } |
| } |
| |
| if(notFoundMap.size()) |
| { |
| std::string notFoundVars; |
| for(std::set<cmStdString>::iterator ii = notFoundMap.begin(); |
| ii != notFoundMap.end(); ++ii) |
| { |
| notFoundVars += *ii; |
| if(manager) |
| { |
| cmCacheManager::CacheIterator it = |
| manager->GetCacheIterator(ii->c_str()); |
| if(it.GetPropertyAsBool("ADVANCED")) |
| { |
| notFoundVars += " (ADVANCED)"; |
| } |
| } |
| notFoundVars += "\n"; |
| } |
| cmSystemTools::Error("This project requires some variables to be set,\n" |
| "and cmake can not find them.\n" |
| "Please set the following variables:\n", |
| notFoundVars.c_str()); |
| } |
| // at this point this->LocalGenerators has been filled, |
| // so create the map from project name to vector of local generators |
| this->FillProjectMap(); |
| if ( !this->CMakeInstance->GetScriptMode() ) |
| { |
| this->CMakeInstance->UpdateProgress("Configuring done", -1); |
| } |
| } |
| |
| void cmGlobalGenerator::Generate() |
| { |
| // For each existing cmLocalGenerator |
| unsigned int i; |
| |
| // Consolidate global targets |
| cmTargets globalTargets; |
| this->CreateDefaultGlobalTargets(&globalTargets); |
| for (i = 0; i < this->LocalGenerators.size(); ++i) |
| { |
| cmTargets* targets = |
| &(this->LocalGenerators[i]->GetMakefile()->GetTargets()); |
| cmTargets::iterator tarIt; |
| for ( tarIt = targets->begin(); tarIt != targets->end(); ++ tarIt ) |
| { |
| if ( tarIt->second.GetType() == cmTarget::GLOBAL_TARGET ) |
| { |
| globalTargets[tarIt->first] = tarIt->second; |
| } |
| } |
| } |
| for (i = 0; i < this->LocalGenerators.size(); ++i) |
| { |
| cmMakefile* mf = this->LocalGenerators[i]->GetMakefile(); |
| cmTargets* targets = &(mf->GetTargets()); |
| cmTargets::iterator tit; |
| for ( tit = globalTargets.begin(); tit != globalTargets.end(); ++ tit ) |
| { |
| (*targets)[tit->first] = tit->second; |
| (*targets)[tit->first].SetMakefile(mf); |
| } |
| } |
| |
| // Compute the manifest of main targets generated. |
| for (i = 0; i < this->LocalGenerators.size(); ++i) |
| { |
| this->LocalGenerators[i]->GenerateTargetManifest(this->TargetManifest); |
| } |
| |
| // Generate project files |
| for (i = 0; i < this->LocalGenerators.size(); ++i) |
| { |
| this->LocalGenerators[i]->Generate(); |
| this->LocalGenerators[i]->GenerateInstallRules(); |
| this->LocalGenerators[i]->GenerateTestFiles(); |
| this->CMakeInstance->UpdateProgress("Generating", |
| (i+1.0f)/this->LocalGenerators.size()); |
| } |
| this->CMakeInstance->UpdateProgress("Generating done", -1); |
| } |
| |
| int cmGlobalGenerator::TryCompile(const char *srcdir, const char *bindir, |
| const char *projectName, |
| const char *target, |
| std::string *output, cmMakefile *mf) |
| { |
| std::string makeCommand = this->CMakeInstance-> |
| GetCacheManager()->GetCacheValue("CMAKE_MAKE_PROGRAM"); |
| if(makeCommand.size() == 0) |
| { |
| cmSystemTools::Error( |
| "Generator cannot find the appropriate make command."); |
| return 1; |
| } |
| |
| std::string newTarget; |
| if (target && strlen(target)) |
| { |
| newTarget += target; |
| #if 0 |
| #if defined(_WIN32) || defined(__CYGWIN__) |
| std::string tmp = target; |
| // if the target does not already end in . something |
| // then assume .exe |
| if(tmp.size() < 4 || tmp[tmp.size()-4] != '.') |
| { |
| newTarget += ".exe"; |
| } |
| #endif // WIN32 |
| #endif |
| } |
| const char* config = mf->GetDefinition("CMAKE_TRY_COMPILE_CONFIGURATION"); |
| return this->Build(srcdir,bindir,projectName, |
| newTarget.c_str(), |
| output,makeCommand.c_str(),config,false,true); |
| } |
| |
| std::string cmGlobalGenerator |
| ::GenerateBuildCommand(const char* makeProgram, const char *projectName, |
| const char* additionalOptions, const char *targetName, |
| const char* config, bool ignoreErrors, bool) |
| { |
| // Project name and config are not used yet. |
| (void)projectName; |
| (void)config; |
| |
| std::string makeCommand = |
| cmSystemTools::ConvertToUnixOutputPath(makeProgram); |
| |
| // Since we have full control over the invocation of nmake, let us |
| // make it quiet. |
| if ( strcmp(this->GetName(), "NMake Makefiles") == 0 ) |
| { |
| makeCommand += " /NOLOGO "; |
| } |
| if ( ignoreErrors ) |
| { |
| makeCommand += " -i"; |
| } |
| if ( additionalOptions ) |
| { |
| makeCommand += " "; |
| makeCommand += additionalOptions; |
| } |
| if ( targetName ) |
| { |
| makeCommand += " "; |
| makeCommand += targetName; |
| } |
| return makeCommand; |
| } |
| |
| int cmGlobalGenerator::Build( |
| const char *, const char *bindir, |
| const char *projectName, const char *target, |
| std::string *output, |
| const char *makeCommandCSTR, |
| const char *config, |
| bool clean, bool fast) |
| { |
| *output += "\nTesting TryCompileWithoutMakefile\n"; |
| |
| /** |
| * Run an executable command and put the stdout in output. |
| */ |
| std::string cwd = cmSystemTools::GetCurrentWorkingDirectory(); |
| cmSystemTools::ChangeDirectory(bindir); |
| |
| int retVal; |
| int timeout = cmGlobalGenerator::s_TryCompileTimeout; |
| bool hideconsole = cmSystemTools::GetRunCommandHideConsole(); |
| cmSystemTools::SetRunCommandHideConsole(true); |
| |
| // should we do a clean first? |
| if (clean) |
| { |
| std::string cleanCommand = |
| this->GenerateBuildCommand(makeCommandCSTR, projectName, |
| 0, "clean", config, false, fast); |
| if (!cmSystemTools::RunSingleCommand(cleanCommand.c_str(), output, |
| &retVal, 0, false, timeout)) |
| { |
| cmSystemTools::SetRunCommandHideConsole(hideconsole); |
| cmSystemTools::Error("Generator: execution of make clean failed."); |
| if (output) |
| { |
| *output += "\nGenerator: execution of make clean failed.\n"; |
| } |
| |
| // return to the original directory |
| cmSystemTools::ChangeDirectory(cwd.c_str()); |
| return 1; |
| } |
| } |
| |
| // now build |
| std::string makeCommand = |
| this->GenerateBuildCommand(makeCommandCSTR, projectName, |
| 0, target, config, false, fast); |
| |
| if (!cmSystemTools::RunSingleCommand(makeCommand.c_str(), output, |
| &retVal, 0, false, timeout)) |
| { |
| cmSystemTools::SetRunCommandHideConsole(hideconsole); |
| cmSystemTools::Error |
| ("Generator: execution of make failed. Make command was: ", |
| makeCommand.c_str()); |
| if (output) |
| { |
| *output += "\nGenerator: execution of make failed. Make command was: " |
| + makeCommand + "\n"; |
| } |
| |
| // return to the original directory |
| cmSystemTools::ChangeDirectory(cwd.c_str()); |
| return 1; |
| } |
| |
| cmSystemTools::SetRunCommandHideConsole(hideconsole); |
| |
| // The SGI MipsPro 7.3 compiler does not return an error code when |
| // the source has a #error in it! This is a work-around for such |
| // compilers. |
| if((retVal == 0) && (output->find("#error") != std::string::npos)) |
| { |
| retVal = 1; |
| } |
| |
| cmSystemTools::ChangeDirectory(cwd.c_str()); |
| return retVal; |
| } |
| |
| void cmGlobalGenerator::AddLocalGenerator(cmLocalGenerator *lg) |
| { |
| this->LocalGenerators.push_back(lg); |
| |
| // update progress |
| // estimate how many lg there will be |
| const char *numGenC = |
| this->CMakeInstance->GetCacheManager()->GetCacheValue |
| ("CMAKE_NUMBER_OF_LOCAL_GENERATORS"); |
| |
| if (!numGenC) |
| { |
| return; |
| } |
| |
| int numGen = atoi(numGenC); |
| float prog = 0.9f*this->LocalGenerators.size()/numGen; |
| if (prog > 0.9f) |
| { |
| prog = 0.9f; |
| } |
| this->CMakeInstance->UpdateProgress("Configuring", prog); |
| } |
| |
| void cmGlobalGenerator::AddInstallComponent(const char* component) |
| { |
| if(component && *component) |
| { |
| this->InstallComponents.insert(component); |
| } |
| } |
| |
| void cmGlobalGenerator::EnableInstallTarget() |
| { |
| this->InstallTargetEnabled = true; |
| } |
| |
| cmLocalGenerator *cmGlobalGenerator::CreateLocalGenerator() |
| { |
| cmLocalGenerator *lg = new cmLocalGenerator; |
| lg->SetGlobalGenerator(this); |
| return lg; |
| } |
| |
| void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen ) |
| { |
| std::string cfp = gen->GetCMakeInstance()->GetHomeOutputDirectory(); |
| cfp += cmake::GetCMakeFilesDirectory(); |
| this->SetConfiguredFilesPath(cfp.c_str()); |
| const char* make = |
| gen->GetCMakeInstance()->GetCacheDefinition("CMAKE_MAKE_PROGRAM"); |
| this->GetCMakeInstance()->AddCacheEntry("CMAKE_MAKE_PROGRAM", make, |
| "make program", |
| cmCacheManager::FILEPATH); |
| // copy the enabled languages |
| this->LanguageEnabled = gen->LanguageEnabled; |
| this->ExtensionToLanguage = gen->ExtensionToLanguage; |
| this->IgnoreExtensions = gen->IgnoreExtensions; |
| this->LanguageToOutputExtension = gen->LanguageToOutputExtension; |
| this->LanguageToLinkerPreference = gen->LanguageToLinkerPreference; |
| this->OutputExtensions = gen->OutputExtensions; |
| } |
| |
| //---------------------------------------------------------------------------- |
| void cmGlobalGenerator::GetDocumentation(cmDocumentationEntry& entry) const |
| { |
| entry.name = this->GetName(); |
| entry.brief = ""; |
| entry.full = ""; |
| } |
| |
| bool cmGlobalGenerator::IsExcluded(cmLocalGenerator* root, |
| cmLocalGenerator* gen) |
| { |
| if(gen == root) |
| { |
| return false; |
| } |
| cmLocalGenerator* cur = gen->GetParent(); |
| while(cur && cur != root) |
| { |
| if(cur->GetExcludeAll()) |
| { |
| return true; |
| } |
| cur = cur->GetParent(); |
| } |
| return gen->GetExcludeAll(); |
| } |
| |
| |
| void cmGlobalGenerator::GetEnabledLanguages(std::vector<std::string>& lang) |
| { |
| for(std::map<cmStdString, bool>::iterator i = |
| this->LanguageEnabled.begin(); i != this->LanguageEnabled.end(); ++i) |
| { |
| lang.push_back(i->first); |
| } |
| } |
| |
| const char* cmGlobalGenerator::GetLinkerPreference(const char* lang) |
| { |
| if(this->LanguageToLinkerPreference.count(lang)) |
| { |
| return this->LanguageToLinkerPreference[lang].c_str(); |
| } |
| return "None"; |
| } |
| |
| |
| void cmGlobalGenerator::FillProjectMap() |
| { |
| this->ProjectMap.clear(); // make sure we start with a clean map |
| unsigned int i; |
| for(i = 0; i < this->LocalGenerators.size(); ++i) |
| { |
| // for each local generator add all projects |
| cmLocalGenerator *lg = this->LocalGenerators[i]; |
| std::string name; |
| do |
| { |
| if (name != lg->GetMakefile()->GetProjectName()) |
| { |
| name = lg->GetMakefile()->GetProjectName(); |
| this->ProjectMap[name].push_back(this->LocalGenerators[i]); |
| } |
| lg = lg->GetParent(); |
| } |
| while (lg); |
| } |
| } |
| |
| |
| ///! Find a local generator by its startdirectory |
| cmLocalGenerator* cmGlobalGenerator::FindLocalGenerator(const char* start_dir) |
| { |
| std::vector<cmLocalGenerator*>* gens = &this->LocalGenerators; |
| for(unsigned int i = 0; i < gens->size(); ++i) |
| { |
| std::string sd = (*gens)[i]->GetMakefile()->GetStartDirectory(); |
| if (sd == start_dir) |
| { |
| return (*gens)[i]; |
| } |
| } |
| return 0; |
| } |
| |
| |
| cmTarget* cmGlobalGenerator::FindTarget(const char* project, |
| const char* name) |
| { |
| // if project specific |
| if(project) |
| { |
| std::vector<cmLocalGenerator*>* gens = &this->ProjectMap[project]; |
| for(unsigned int i = 0; i < gens->size(); ++i) |
| { |
| cmTarget* ret = (*gens)[i]->GetMakefile()->FindTarget(name); |
| if(ret) |
| { |
| return ret; |
| } |
| } |
| } |
| // if all projects/directories |
| else |
| { |
| std::map<cmStdString,cmTarget *>::iterator i = |
| this->TotalTargets.find(name); |
| if (i == this->TotalTargets.end()) |
| { |
| return 0; |
| } |
| return i->second; |
| } |
| return 0; |
| } |
| |
| //---------------------------------------------------------------------------- |
| void cmGlobalGenerator::ConfigureRelativePaths() |
| { |
| // The current working directory on Windows cannot be a network |
| // path. Therefore relative paths cannot work when the build tree |
| // is a network path. |
| std::string source = this->CMakeInstance->GetHomeDirectory(); |
| std::string binary = this->CMakeInstance->GetHomeOutputDirectory(); |
| if(binary.size() < 2 || binary.substr(0, 2) != "//") |
| { |
| this->RelativePathTopSource = source; |
| this->RelativePathTopBinary = binary; |
| } |
| else |
| { |
| this->RelativePathTopSource = ""; |
| this->RelativePathTopBinary = ""; |
| } |
| } |
| |
| //---------------------------------------------------------------------------- |
| std::string cmGlobalGenerator |
| ::ConvertToRelativePath(const std::vector<std::string>& local, |
| const char* in_remote) |
| { |
| // The path should never be quoted. |
| assert(in_remote[0] != '\"'); |
| |
| // The local path should never have a trailing slash. |
| assert(local.size() > 0 && !(local[local.size()-1] == "")); |
| |
| // If the path is already relative then just return the path. |
| if(!cmSystemTools::FileIsFullPath(in_remote)) |
| { |
| return in_remote; |
| } |
| |
| // Make sure relative path conversion is configured. |
| if(!this->RelativePathsConfigured) |
| { |
| this->ConfigureRelativePaths(); |
| this->RelativePathsConfigured = true; |
| } |
| |
| std::string original = in_remote; |
| |
| // Skip conversion if the path and local are not both in the source or both |
| // in the binary tree |
| std::string local_path = cmSystemTools::JoinPath(local); |
| bool should_convert = false; |
| |
| // is the root in the binary tree? |
| if (local_path.size() >= this->RelativePathTopBinary.size() && |
| cmSystemTools::ComparePath |
| (local_path.substr(0, this->RelativePathTopBinary.size()).c_str(), |
| this->RelativePathTopBinary.c_str())) |
| { |
| // is the source also in the binary tree? |
| if (original.size() >= this->RelativePathTopBinary.size() && |
| cmSystemTools::ComparePath |
| (original.substr(0, this->RelativePathTopBinary.size()).c_str(), |
| this->RelativePathTopBinary.c_str())) |
| { |
| should_convert = true; |
| } |
| } |
| |
| if (local_path.size() >= this->RelativePathTopSource.size() && |
| cmSystemTools::ComparePath |
| (local_path.substr(0, this->RelativePathTopSource.size()).c_str(), |
| this->RelativePathTopSource.c_str())) |
| { |
| // is the source also in the binary tree? |
| if (original.size() >= this->RelativePathTopSource.size() && |
| cmSystemTools::ComparePath |
| (original.substr(0, this->RelativePathTopSource.size()).c_str(), |
| this->RelativePathTopSource.c_str())) |
| { |
| should_convert = true; |
| } |
| } |
| |
| if (!should_convert) |
| { |
| return in_remote; |
| } |
| |
| // Identify the longest shared path component between the remote |
| // path and the local path. |
| std::vector<std::string> remote; |
| cmSystemTools::SplitPath(in_remote, remote); |
| unsigned int common=0; |
| while(common < remote.size() && |
| common < local.size() && |
| cmSystemTools::ComparePath(remote[common].c_str(), |
| local[common].c_str())) |
| { |
| ++common; |
| } |
| |
| // If no part of the path is in common then return the full path. |
| if(common == 0) |
| { |
| return in_remote; |
| } |
| |
| // If the entire path is in common then just return a ".". |
| if(common == remote.size() && |
| common == local.size()) |
| { |
| return "."; |
| } |
| |
| // If the entire path is in common except for a trailing slash then |
| // just return a "./". |
| if(common+1 == remote.size() && |
| remote[common].size() == 0 && |
| common == local.size()) |
| { |
| return "./"; |
| } |
| |
| // Construct the relative path. |
| std::string relative; |
| |
| // First add enough ../ to get up to the level of the shared portion |
| // of the path. Leave off the trailing slash. Note that the last |
| // component of local will never be empty because local should never |
| // have a trailing slash. |
| for(unsigned int i=common; i < local.size(); ++i) |
| { |
| relative += ".."; |
| if(i < local.size()-1) |
| { |
| relative += "/"; |
| } |
| } |
| |
| // Now add the portion of the destination path that is not included |
| // in the shared portion of the path. Add a slash the first time |
| // only if there was already something in the path. If there was a |
| // trailing slash in the input then the last iteration of the loop |
| // will add a slash followed by an empty string which will preserve |
| // the trailing slash in the output. |
| for(unsigned int i=common; i < remote.size(); ++i) |
| { |
| if(relative.size() > 0) |
| { |
| relative += "/"; |
| } |
| relative += remote[i]; |
| } |
| |
| // Finally return the path. |
| return relative; |
| } |
| |
| inline std::string removeQuotes(const std::string& s) |
| { |
| if(s[0] == '\"' && s[s.size()-1] == '\"') |
| { |
| return s.substr(1, s.size()-2); |
| } |
| return s; |
| } |
| |
| void cmGlobalGenerator::SetCMakeInstance(cmake* cm) |
| { |
| // Store a pointer to the cmake object instance. |
| this->CMakeInstance = cm; |
| } |
| |
| void cmGlobalGenerator::SetupTests() |
| { |
| std::string ctest = this->LocalGenerators[0]->GetMakefile()-> |
| GetRequiredDefinition("CMAKE_COMMAND"); |
| ctest = removeQuotes(ctest); |
| ctest = cmSystemTools::GetFilenamePath(ctest.c_str()); |
| ctest += "/"; |
| ctest += "ctest"; |
| ctest += cmSystemTools::GetExecutableExtension(); |
| if(!cmSystemTools::FileExists(ctest.c_str())) |
| { |
| ctest = this->LocalGenerators[0]->GetMakefile()-> |
| GetRequiredDefinition("CMAKE_COMMAND"); |
| ctest = cmSystemTools::GetFilenamePath(ctest.c_str()); |
| ctest += "/Debug/"; |
| ctest += "ctest"; |
| ctest += cmSystemTools::GetExecutableExtension(); |
| } |
| if(!cmSystemTools::FileExists(ctest.c_str())) |
| { |
| ctest = this->LocalGenerators[0]->GetMakefile()-> |
| GetRequiredDefinition("CMAKE_COMMAND"); |
| ctest = cmSystemTools::GetFilenamePath(ctest.c_str()); |
| ctest += "/Release/"; |
| ctest += "ctest"; |
| ctest += cmSystemTools::GetExecutableExtension(); |
| } |
| // if we found ctest |
| if (cmSystemTools::FileExists(ctest.c_str())) |
| { |
| // Create a full path filename for output Testfile |
| std::string fname; |
| fname = this->CMakeInstance->GetStartOutputDirectory(); |
| fname += "/"; |
| if ( this->LocalGenerators[0]->GetMakefile()->IsSet("CTEST_NEW_FORMAT") ) |
| { |
| fname += "CTestTestfile.txt"; |
| } |
| else |
| { |
| fname += "DartTestfile.txt"; |
| } |
| |
| // Add run_test only if any tests are foun |
| size_t total_tests = 0; |
| size_t i; |
| for (i = 0; i < this->LocalGenerators.size(); ++i) |
| { |
| total_tests += |
| this->LocalGenerators[i]->GetMakefile()->GetTests()->size(); |
| } |
| |
| // If the file doesn't exist, then ENABLE_TESTING hasn't been run |
| if (total_tests > 0) |
| { |
| const char* no_working_dir = 0; |
| std::vector<std::string> no_depends; |
| std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it; |
| for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it) |
| { |
| std::vector<cmLocalGenerator*>& gen = it->second; |
| // add the RUN_TESTS to the first local generator of each project |
| if(gen.size()) |
| { |
| cmMakefile* mf = gen[0]->GetMakefile(); |
| if(const char* outDir = mf->GetDefinition("CMAKE_CFG_INTDIR")) |
| { |
| mf->AddUtilityCommand("RUN_TESTS", false, no_depends, |
| no_working_dir, |
| ctest.c_str(), "-C", outDir); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets) |
| { |
| cmMakefile* mf = this->LocalGenerators[0]->GetMakefile(); |
| const char* cmakeCfgIntDir = this->GetCMakeCFGInitDirectory(); |
| const char* cmakeCommand = mf->GetRequiredDefinition("CMAKE_COMMAND"); |
| |
| // CPack |
| cmCustomCommandLines cpackCommandLines; |
| std::vector<std::string> depends; |
| cmCustomCommandLine singleLine; |
| cpackCommandLines.erase(cpackCommandLines.begin(), cpackCommandLines.end()); |
| singleLine.erase(singleLine.begin(), singleLine.end()); |
| depends.erase(depends.begin(), depends.end()); |
| singleLine.push_back(this->GetCMakeInstance()->GetCPackCommand()); |
| if ( cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.' ) |
| { |
| singleLine.push_back("-C"); |
| singleLine.push_back(cmakeCfgIntDir); |
| } |
| singleLine.push_back("--config"); |
| std::string configFile = mf->GetStartOutputDirectory();; |
| configFile += "/CPackConfig.cmake"; |
| singleLine.push_back(configFile); |
| cpackCommandLines.push_back(singleLine); |
| if ( this->GetPreinstallTargetName() ) |
| { |
| depends.push_back("preinstall"); |
| } |
| if(cmSystemTools::FileExists(configFile.c_str())) |
| { |
| (*targets)[this->GetPackageTargetName()] |
| = this->CreateGlobalTarget(this->GetPackageTargetName(), |
| "Run CPack packaging tool...", |
| &cpackCommandLines, depends); |
| } |
| // CPack source |
| const char* packageSourceTargetName = this->GetPackageSourceTargetName(); |
| if ( packageSourceTargetName ) |
| { |
| cpackCommandLines.erase(cpackCommandLines.begin(), |
| cpackCommandLines.end()); |
| singleLine.erase(singleLine.begin(), singleLine.end()); |
| depends.erase(depends.begin(), depends.end()); |
| singleLine.push_back(this->GetCMakeInstance()->GetCPackCommand()); |
| singleLine.push_back("--config"); |
| configFile = mf->GetStartOutputDirectory();; |
| configFile += "/CPackSourceConfig.cmake"; |
| if(cmSystemTools::FileExists(configFile.c_str())) |
| { |
| singleLine.push_back(configFile); |
| cpackCommandLines.push_back(singleLine); |
| (*targets)[packageSourceTargetName] |
| = this->CreateGlobalTarget(packageSourceTargetName, |
| "Run CPack packaging tool for source...", |
| &cpackCommandLines, depends); |
| } |
| } |
| |
| // Test |
| if(mf->IsOn("CMAKE_TESTING_ENABLED")) |
| { |
| cpackCommandLines.erase(cpackCommandLines.begin(), |
| cpackCommandLines.end()); |
| singleLine.erase(singleLine.begin(), singleLine.end()); |
| depends.erase(depends.begin(), depends.end()); |
| singleLine.push_back(this->GetCMakeInstance()->GetCTestCommand()); |
| singleLine.push_back("--force-new-ctest-process"); |
| if(cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.') |
| { |
| singleLine.push_back("-C"); |
| singleLine.push_back(mf->GetDefinition("CMAKE_CFG_INTDIR")); |
| } |
| else // TODO: This is a hack. Should be something to do with the generator |
| { |
| singleLine.push_back("$(ARGS)"); |
| } |
| cpackCommandLines.push_back(singleLine); |
| (*targets)[this->GetTestTargetName()] |
| = this->CreateGlobalTarget(this->GetTestTargetName(), |
| "Running tests...", &cpackCommandLines, depends); |
| } |
| |
| //Edit Cache |
| const char* editCacheTargetName = this->GetEditCacheTargetName(); |
| if ( editCacheTargetName ) |
| { |
| cpackCommandLines.erase(cpackCommandLines.begin(), |
| cpackCommandLines.end()); |
| singleLine.erase(singleLine.begin(), singleLine.end()); |
| depends.erase(depends.begin(), depends.end()); |
| |
| // Use CMAKE_EDIT_COMMAND for the edit_cache rule if it is defined. |
| // Otherwise default to the interactive command-line interface. |
| if(mf->GetDefinition("CMAKE_EDIT_COMMAND")) |
| { |
| singleLine.push_back(mf->GetDefinition("CMAKE_EDIT_COMMAND")); |
| singleLine.push_back("-H$(CMAKE_SOURCE_DIR)"); |
| singleLine.push_back("-B$(CMAKE_BINARY_DIR)"); |
| cpackCommandLines.push_back(singleLine); |
| (*targets)[editCacheTargetName] = |
| this->CreateGlobalTarget( |
| editCacheTargetName, "Running CMake cache editor...", |
| &cpackCommandLines, depends); |
| } |
| else |
| { |
| singleLine.push_back(cmakeCommand); |
| singleLine.push_back("-i"); |
| singleLine.push_back("."); |
| cpackCommandLines.push_back(singleLine); |
| (*targets)[editCacheTargetName] = |
| this->CreateGlobalTarget( |
| editCacheTargetName, |
| "Running interactive CMake command-line interface...", |
| &cpackCommandLines, depends); |
| } |
| } |
| |
| //Rebuild Cache |
| const char* rebuildCacheTargetName = this->GetRebuildCacheTargetName(); |
| if ( rebuildCacheTargetName ) |
| { |
| cpackCommandLines.erase(cpackCommandLines.begin(), |
| cpackCommandLines.end()); |
| singleLine.erase(singleLine.begin(), singleLine.end()); |
| depends.erase(depends.begin(), depends.end()); |
| singleLine.push_back(cmakeCommand); |
| singleLine.push_back("-H$(CMAKE_SOURCE_DIR)"); |
| singleLine.push_back("-B$(CMAKE_BINARY_DIR)"); |
| cpackCommandLines.push_back(singleLine); |
| (*targets)[rebuildCacheTargetName] = |
| this->CreateGlobalTarget( |
| rebuildCacheTargetName, "Running CMake to regenerate build system...", |
| &cpackCommandLines, depends); |
| } |
| |
| //Install |
| if(this->InstallTargetEnabled) |
| { |
| if(!cmakeCfgIntDir || !*cmakeCfgIntDir || cmakeCfgIntDir[0] == '.') |
| { |
| std::set<cmStdString>* componentsSet = &this->InstallComponents; |
| cpackCommandLines.erase(cpackCommandLines.begin(), |
| cpackCommandLines.end()); |
| depends.erase(depends.begin(), depends.end()); |
| cmOStringStream ostr; |
| if ( componentsSet->size() > 0 ) |
| { |
| ostr << "Available install components are:"; |
| std::set<cmStdString>::iterator it; |
| for ( |
| it = componentsSet->begin(); |
| it != componentsSet->end(); |
| ++ it ) |
| { |
| ostr << " \"" << it->c_str() << "\""; |
| } |
| } |
| else |
| { |
| ostr << "Only default component available"; |
| } |
| singleLine.push_back(ostr.str().c_str()); |
| (*targets)["list_install_components"] |
| = this->CreateGlobalTarget("list_install_components", |
| ostr.str().c_str(), |
| &cpackCommandLines, depends); |
| } |
| std::string cmd; |
| cpackCommandLines.erase(cpackCommandLines.begin(), |
| cpackCommandLines.end()); |
| singleLine.erase(singleLine.begin(), singleLine.end()); |
| depends.erase(depends.begin(), depends.end()); |
| if ( this->GetPreinstallTargetName() ) |
| { |
| depends.push_back(this->GetPreinstallTargetName()); |
| } |
| else |
| { |
| const char* noall = |
| mf->GetDefinition("CMAKE_SKIP_INSTALL_ALL_DEPENDENCY"); |
| if(!noall || cmSystemTools::IsOff(noall)) |
| { |
| depends.push_back(this->GetAllTargetName()); |
| } |
| } |
| if(mf->GetDefinition("CMake_BINARY_DIR")) |
| { |
| // We are building CMake itself. We cannot use the original |
| // executable to install over itself. |
| cmd = mf->GetDefinition("EXECUTABLE_OUTPUT_PATH"); |
| if(cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.') |
| { |
| cmd += "/"; |
| cmd += cmakeCfgIntDir; |
| } |
| cmd += "/cmake"; |
| } |
| else |
| { |
| cmd = cmakeCommand; |
| } |
| singleLine.push_back(cmd.c_str()); |
| if ( cmakeCfgIntDir && *cmakeCfgIntDir && cmakeCfgIntDir[0] != '.' ) |
| { |
| std::string cfgArg = "-DBUILD_TYPE="; |
| cfgArg += mf->GetDefinition("CMAKE_CFG_INTDIR"); |
| singleLine.push_back(cfgArg); |
| } |
| singleLine.push_back("-P"); |
| singleLine.push_back("cmake_install.cmake"); |
| cpackCommandLines.push_back(singleLine); |
| (*targets)[this->GetInstallTargetName()] = |
| this->CreateGlobalTarget( |
| this->GetInstallTargetName(), "Install the project...", |
| &cpackCommandLines, depends); |
| |
| // install_local |
| if(const char* install_local = this->GetInstallLocalTargetName()) |
| { |
| singleLine.insert(singleLine.begin()+1, "-DCMAKE_INSTALL_LOCAL_ONLY=1"); |
| cpackCommandLines.erase(cpackCommandLines.begin(), |
| cpackCommandLines.end()); |
| cpackCommandLines.push_back(singleLine); |
| |
| (*targets)[install_local] = |
| this->CreateGlobalTarget( |
| install_local, "Installing only the local directory...", |
| &cpackCommandLines, depends); |
| } |
| } |
| } |
| |
| cmTarget cmGlobalGenerator::CreateGlobalTarget( |
| const char* name, const char* message, |
| const cmCustomCommandLines* commandLines, |
| std::vector<std::string> depends, |
| bool depends_on_all /* = false */) |
| { |
| // Package |
| cmTarget target; |
| target.SetType(cmTarget::GLOBAL_TARGET, name); |
| target.SetInAll(false); |
| |
| std::vector<std::string> no_outputs; |
| std::vector<std::string> no_depends; |
| // Store the custom command in the target. |
| cmCustomCommand cc(no_outputs, no_depends, *commandLines, 0, 0); |
| target.GetPostBuildCommands().push_back(cc); |
| target.SetProperty("EchoString", message); |
| if ( depends_on_all ) |
| { |
| target.AddUtility("all"); |
| } |
| std::vector<std::string>::iterator dit; |
| for ( dit = depends.begin(); dit != depends.end(); ++ dit ) |
| { |
| target.AddUtility(dit->c_str()); |
| } |
| return target; |
| } |
| |
| //---------------------------------------------------------------------------- |
| void cmGlobalGenerator::AppendDirectoryForConfig(const char*, const char*, |
| const char*, std::string&) |
| { |
| // Subclasses that support multiple configurations should implement |
| // this method to append the subdirectory for the given build |
| // configuration. |
| } |
| |
| //---------------------------------------------------------------------------- |
| void cmGlobalGenerator::CheckMultipleOutputs(cmMakefile*, bool) |
| { |
| // Only certain generators need this check. They define this |
| // method. |
| } |
