diff options
| -rw-r--r-- | Source/cmFindBase.cxx | 255 | ||||
| -rw-r--r-- | Source/cmFindBase.h | 24 | ||||
| -rw-r--r-- | Source/cmFindCommon.cxx | 129 | ||||
| -rw-r--r-- | Source/cmFindCommon.h | 34 | ||||
| -rw-r--r-- | Source/cmFindLibraryCommand.cxx | 2 | ||||
| -rw-r--r-- | Source/cmFindPackageCommand.cxx | 245 | ||||
| -rw-r--r-- | Source/cmFindPackageCommand.h | 27 |
7 files changed, 395 insertions, 321 deletions
diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx index e4e819a..2b9acae 100644 --- a/Source/cmFindBase.cxx +++ b/Source/cmFindBase.cxx @@ -140,11 +140,11 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn) } else if(doing == DoingPaths) { - this->AddUserPath(args[j], this->UserPaths); + this->AddUserPath(args[j], this->UserGuessPaths); } else if(doing == DoingHints) { - this->AddUserPath(args[j], this->UserHints); + this->AddUserPath(args[j], this->UserHintsPaths); } else if(doing == DoingPathSuffixes) { @@ -186,16 +186,11 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn) this->Names.push_back(shortArgs[0]); for(unsigned int j = 1; j < shortArgs.size(); ++j) { - this->AddUserPath(shortArgs[j], this->UserPaths); + this->AddUserPath(shortArgs[j], this->UserGuessPaths); } } this->ExpandPaths(); - // Filter out ignored paths from the prefix list - std::set<std::string> ignored; - this->GetIgnoredPaths(ignored); - this->FilterPaths(this->SearchPaths, ignored); - this->ComputeFinalPaths(); return true; @@ -203,20 +198,40 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn) void cmFindBase::ExpandPaths() { - this->AddCMakeVariablePath(); - this->AddCMakeEnvironmentPath(); - this->AddUserHintsPath(); - this->AddSystemEnvironmentPath(); - this->AddCMakeSystemVariablePath(); - this->AddUserGuessPath(); - - // Add suffixes and clean up paths. - this->AddPathSuffixes(); + if(!this->NoDefaultPath) + { + if(!this->NoCMakePath) + { + this->FillCMakeVariablePath(); + this->AddPathSuffixes(this->CMakeVariablePaths); + } + if(!this->NoCMakeEnvironmentPath) + { + this->FillCMakeEnvironmentPath(); + this->AddPathSuffixes(this->CMakeEnvironmentPaths); + } + if(!this->NoSystemEnvironmentPath) + { + this->FillSystemEnvironmentPath(); + this->AddPathSuffixes(this->SystemEnvironmentPaths); + } + if(!this->NoCMakeSystemPath) + { + this->FillCMakeSystemVariablePath(); + this->AddPathSuffixes(this->CMakeSystemVariablePaths); + } + } + + this->FillUserHintsPath(); + this->AddPathSuffixes(this->UserHintsPaths); + this->FillUserGuessPath(); + this->AddPathSuffixes(this->UserGuessPaths); } //---------------------------------------------------------------------------- -void cmFindBase::AddPrefixPaths(std::vector<std::string> const& in_paths, - PathType pathType) +void cmFindBase::AddPrefixPaths(std::vector<std::string> const& inPaths, + PathType pt, + std::vector<std::string>& outPaths) { // default for programs std::string subdir = "bin"; @@ -234,8 +249,8 @@ void cmFindBase::AddPrefixPaths(std::vector<std::string> const& in_paths, subdir = ""; // ? what to do for frameworks ? } - for(std::vector<std::string>::const_iterator it = in_paths.begin(); - it != in_paths.end(); ++it) + for(std::vector<std::string>::const_iterator it = inPaths.begin(); + it != inPaths.end(); ++it) { std::string dir = *it; if(!subdir.empty() && !dir.empty() && dir[dir.size()-1] != '/') @@ -248,178 +263,173 @@ void cmFindBase::AddPrefixPaths(std::vector<std::string> const& in_paths, this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE"); if(arch && *arch) { - this->AddPathInternal(dir+subdir+"/"+arch, pathType); + this->AddPathInternal(this->MakeFullPath(dir+subdir+"/"+arch, pt), + outPaths); } } std::string add = dir + subdir; if(add != "/") { - this->AddPathInternal(add, pathType); + this->AddPathInternal(this->MakeFullPath(add, pt), outPaths); } if (subdir == "bin") { - this->AddPathInternal(dir+"sbin", pathType); + this->AddPathInternal(this->MakeFullPath(dir+"sbin", pt), outPaths); } if(!subdir.empty() && *it != "/") { - this->AddPathInternal(*it, pathType); + this->AddPathInternal(this->MakeFullPath(*it, pt), outPaths); } } } //---------------------------------------------------------------------------- -void cmFindBase::AddCMakePrefixPath(const std::string& variable) +void cmFindBase::AddCMakePrefixPath(const std::string& variable, + std::vector<std::string>& outPaths) { // Get a path from a CMake variable. if(const char* varPath = this->Makefile->GetDefinition(variable)) { std::vector<std::string> tmp; cmSystemTools::ExpandListArgument(varPath, tmp); - this->AddPrefixPaths(tmp, CMakePath); + this->AddPrefixPaths(tmp, CMakePath, outPaths); } } //---------------------------------------------------------------------------- -void cmFindBase::AddEnvPrefixPath(const std::string& variable) +void cmFindBase::AddEnvPrefixPath(const std::string& variable, + std::vector<std::string>& outPaths) { // Get a path from the environment. std::vector<std::string> tmp; cmSystemTools::GetPath(tmp, variable.c_str()); - this->AddPrefixPaths(tmp, EnvPath); + this->AddPrefixPaths(tmp, EnvPath, outPaths); } //---------------------------------------------------------------------------- -void cmFindBase::AddCMakeEnvironmentPath() +void cmFindBase::FillCMakeEnvironmentPath() { - if(!this->NoCMakeEnvironmentPath && !this->NoDefaultPath) + // Add CMAKE_*_PATH environment variables + std::string var = "CMAKE_"; + var += this->CMakePathName; + var += "_PATH"; + this->AddEnvPrefixPath("CMAKE_PREFIX_PATH", this->CMakeEnvironmentPaths); + this->AddEnvPath(var.c_str(), this->CMakeEnvironmentPaths); + + if(this->CMakePathName == "PROGRAM") { - // Add CMAKE_*_PATH environment variables - std::string var = "CMAKE_"; - var += this->CMakePathName; - var += "_PATH"; - this->AddEnvPrefixPath("CMAKE_PREFIX_PATH"); - this->AddEnvPath(var.c_str()); - - if(this->CMakePathName == "PROGRAM") - { - this->AddEnvPath("CMAKE_APPBUNDLE_PATH"); - } - else - { - this->AddEnvPath("CMAKE_FRAMEWORK_PATH"); - } + this->AddEnvPath("CMAKE_APPBUNDLE_PATH", this->CMakeEnvironmentPaths); + } + else + { + this->AddEnvPath("CMAKE_FRAMEWORK_PATH", this->CMakeEnvironmentPaths); } } //---------------------------------------------------------------------------- -void cmFindBase::AddCMakeVariablePath() +void cmFindBase::FillCMakeVariablePath() { - if(!this->NoCMakePath && !this->NoDefaultPath) + // Add CMake varibles of the same name as the previous environment + // varibles CMAKE_*_PATH to be used most of the time with -D + // command line options + std::string var = "CMAKE_"; + var += this->CMakePathName; + var += "_PATH"; + this->AddCMakePrefixPath("CMAKE_PREFIX_PATH", this->CMakeVariablePaths); + this->AddCMakePath(var, this->CMakeVariablePaths); + + if(this->CMakePathName == "PROGRAM") { - // Add CMake varibles of the same name as the previous environment - // varibles CMAKE_*_PATH to be used most of the time with -D - // command line options - std::string var = "CMAKE_"; - var += this->CMakePathName; - var += "_PATH"; - this->AddCMakePrefixPath("CMAKE_PREFIX_PATH"); - this->AddCMakePath(var); - - if(this->CMakePathName == "PROGRAM") - { - this->AddCMakePath("CMAKE_APPBUNDLE_PATH"); - } - else - { - this->AddCMakePath("CMAKE_FRAMEWORK_PATH"); - } + this->AddCMakePath("CMAKE_APPBUNDLE_PATH", this->CMakeVariablePaths); + } + else + { + this->AddCMakePath("CMAKE_FRAMEWORK_PATH", this->CMakeVariablePaths); } } //---------------------------------------------------------------------------- -void cmFindBase::AddSystemEnvironmentPath() +void cmFindBase::FillSystemEnvironmentPath() { - if(!this->NoSystemEnvironmentPath && !this->NoDefaultPath) + // Add LIB or INCLUDE + if(!this->EnvironmentPath.empty()) { - // Add LIB or INCLUDE - if(!this->EnvironmentPath.empty()) - { - this->AddEnvPath(this->EnvironmentPath.c_str()); - } - // Add PATH - this->AddEnvPath(0); + this->AddEnvPath(this->EnvironmentPath.c_str(), + this->SystemEnvironmentPaths); } + // Add PATH + this->AddEnvPath(0, this->SystemEnvironmentPaths); } //---------------------------------------------------------------------------- -void cmFindBase::AddCMakeSystemVariablePath() +void cmFindBase::FillCMakeSystemVariablePath() { - if(!this->NoCMakeSystemPath && !this->NoDefaultPath) + std::string var = "CMAKE_SYSTEM_"; + var += this->CMakePathName; + var += "_PATH"; + this->AddCMakePrefixPath("CMAKE_SYSTEM_PREFIX_PATH", + this->CMakeSystemVariablePaths); + this->AddCMakePath(var, this->CMakeSystemVariablePaths); + + if(this->CMakePathName == "PROGRAM") { - std::string var = "CMAKE_SYSTEM_"; - var += this->CMakePathName; - var += "_PATH"; - this->AddCMakePrefixPath("CMAKE_SYSTEM_PREFIX_PATH"); - this->AddCMakePath(var); - - if(this->CMakePathName == "PROGRAM") - { - this->AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH"); - } - else - { - this->AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH"); - } + this->AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH", + this->CMakeSystemVariablePaths); + } + else + { + this->AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH", + this->CMakeSystemVariablePaths); } } //---------------------------------------------------------------------------- -void cmFindBase::AddUserHintsPath() +void cmFindBase::FillUserHintsPath() { - this->AddPathsInternal(this->UserHints, CMakePath); + std::vector<std::string> inPaths; + inPaths.swap(this->UserHintsPaths); + this->AddPathsInternal(inPaths, CMakePath, this->UserHintsPaths); } //---------------------------------------------------------------------------- -void cmFindBase::AddUserGuessPath() +void cmFindBase::FillUserGuessPath() { - this->AddPathsInternal(this->UserPaths, CMakePath); + std::vector<std::string> inPaths; + inPaths.swap(this->UserGuessPaths); + this->AddPathsInternal(inPaths, CMakePath, this->UserGuessPaths); } //---------------------------------------------------------------------------- -void cmFindBase::AddPathSuffixes() +void cmFindBase::AddPathSuffixes(std::vector<std::string>& paths) { - std::vector<std::string>& paths = this->SearchPaths; - std::vector<std::string> finalPath = paths; - std::vector<std::string>::iterator i; - // clear the path - paths.clear(); - // convert all paths to unix slashes and add search path suffixes - // if there are any - for(i = finalPath.begin(); - i != finalPath.end(); ++i) + std::vector<std::string> inPaths; + inPaths.swap(paths); + paths.reserve(inPaths.size()*(this->SearchPathSuffixes.size()+1)); + + for(std::vector<std::string>::iterator ip = inPaths.begin(); + ip != inPaths.end(); ++ip) { - cmSystemTools::ConvertToUnixSlashes(*i); - // copy each finalPath combined with SearchPathSuffixes - // to the SearchPaths ivar - for(std::vector<std::string>::iterator j = + cmSystemTools::ConvertToUnixSlashes(*ip); + + // if *i is only / then do not add a // + // this will get incorrectly considered a network + // path on windows and cause huge delays. + std::string p = *ip; + if(!p.empty() && *p.rbegin() != '/') + { + p += "/"; + } + + for(std::vector<std::string>::iterator sps = this->SearchPathSuffixes.begin(); - j != this->SearchPathSuffixes.end(); ++j) + sps != this->SearchPathSuffixes.end(); ++sps) { - // if *i is only / then do not add a // - // this will get incorrectly considered a network - // path on windows and cause huge delays. - std::string p = *i; - if(p.size() && p[p.size()-1] != '/') - { - p += std::string("/"); - } - p += *j; // add to all paths because the search path may be modified // later with lib being replaced for lib64 which may exist - paths.push_back(p); + paths.push_back(p+*sps); } // now put the path without the path suffixes in the SearchPaths - paths.push_back(*i); + paths.push_back(*ip); } } @@ -457,9 +467,10 @@ void cmFindBase::PrintFindStuff() } std::cerr << "\n"; std::cerr << "SearchPaths\n"; - for(unsigned int i =0; i < this->SearchPaths.size(); ++i) + for(std::vector<std::string>::const_iterator i = this->SearchPaths.begin(); + i != this->SearchPaths.end(); ++i) { - std::cerr << "[" << this->SearchPaths[i] << "]\n"; + std::cerr << "[" << *i << "]\n"; } } diff --git a/Source/cmFindBase.h b/Source/cmFindBase.h index 42d9bc1..14f22c2 100644 --- a/Source/cmFindBase.h +++ b/Source/cmFindBase.h @@ -34,7 +34,7 @@ public: protected: void PrintFindStuff(); void ExpandPaths(); - void AddPathSuffixes(); + void AddPathSuffixes(std::vector<std::string>& paths); // see if the VariableName is already set in the cache, // also copy the documentation from the cache to VariableDocumentation @@ -55,18 +55,20 @@ protected: bool AlreadyInCacheWithoutMetaInfo; private: // Add pieces of the search. - void AddCMakeEnvironmentPath(); - void AddCMakeVariablePath(); - void AddSystemEnvironmentPath(); - void AddCMakeSystemVariablePath(); - void AddUserHintsPath(); - void AddUserGuessPath(); + void FillCMakeVariablePath(); + void FillCMakeEnvironmentPath(); + void FillUserHintsPath(); + void FillSystemEnvironmentPath(); + void FillCMakeSystemVariablePath(); + void FillUserGuessPath(); // Helpers. - void AddCMakePrefixPath(const std::string& variable); - void AddEnvPrefixPath(const std::string& variable); - void AddPrefixPaths(std::vector<std::string> const& in_paths, - PathType pathType); + void AddCMakePrefixPath(const std::string& variable, + std::vector<std::string>& outPaths); + void AddEnvPrefixPath(const std::string& variable, + std::vector<std::string>& outPaths); + void AddPrefixPaths(std::vector<std::string> const& inPaths, + PathType pathType, std::vector<std::string>& outPaths); }; diff --git a/Source/cmFindCommon.cxx b/Source/cmFindCommon.cxx index 6376d42..aea8e4e 100644 --- a/Source/cmFindCommon.cxx +++ b/Source/cmFindCommon.cxx @@ -10,6 +10,8 @@ See the License for more information. ============================================================================*/ #include "cmFindCommon.h" +#include <functional> +#include <algorithm> //---------------------------------------------------------------------------- cmFindCommon::cmFindCommon() @@ -42,6 +44,22 @@ cmFindCommon::~cmFindCommon() } //---------------------------------------------------------------------------- +std::string cmFindCommon::MakeFullPath(const std::string& path, + PathType pathType) +{ + // Select the base path with which to interpret relative paths. + if(pathType == CMakePath) + { + return cmSystemTools::CollapseFullPath( + path, this->Makefile->GetCurrentDirectory()); + } + else + { + return cmSystemTools::CollapseFullPath(path, 0); + } +} + +//---------------------------------------------------------------------------- void cmFindCommon::SelectDefaultRootPathMode() { // Use both by default. @@ -212,24 +230,20 @@ void cmFindCommon::RerootPaths(std::vector<std::string>& paths) } //---------------------------------------------------------------------------- -void cmFindCommon::FilterPaths(std::vector<std::string>& paths, - const std::set<std::string>& ignore) +void cmFindCommon::FilterPaths(const std::vector<std::string>& inPaths, + const std::set<std::string>& ignore, + std::vector<std::string>& outPaths) { - // Now filter out anything that's in the ignore set. - std::vector<std::string> unfiltered; - unfiltered.swap(paths); - - for(std::vector<std::string>::iterator pi = unfiltered.begin(); - pi != unfiltered.end(); ++pi) + for(std::vector<std::string>::const_iterator i = inPaths.begin(); + i != inPaths.end(); ++i) { - if (ignore.count(*pi) == 0) + if(ignore.count(*i) == 0) { - paths.push_back(*pi); + outPaths.push_back(*i); } } } - //---------------------------------------------------------------------------- void cmFindCommon::GetIgnoredPaths(std::vector<std::string>& ignore) { @@ -345,8 +359,8 @@ void cmFindCommon::AddPathSuffix(std::string const& arg) } //---------------------------------------------------------------------------- -void cmFindCommon::AddUserPath(std::string const& p, - std::vector<std::string>& paths) +void cmFindCommon::AddUserPath(std::string const& inPath, + std::vector<std::string>& outPaths) { // We should view the registry as the target application would view // it. @@ -359,22 +373,23 @@ void cmFindCommon::AddUserPath(std::string const& p, } // Expand using the view of the target application. - std::string expanded = p; + std::string expanded = inPath; cmSystemTools::ExpandRegistryValues(expanded, view); - cmSystemTools::GlobDirs(expanded, paths); + cmSystemTools::GlobDirs(expanded, outPaths); // Executables can be either 32-bit or 64-bit, so expand using the // alternative view. - if(expanded != p && this->CMakePathName == "PROGRAM") + if(expanded != inPath && this->CMakePathName == "PROGRAM") { - expanded = p; + expanded = inPath; cmSystemTools::ExpandRegistryValues(expanded, other_view); - cmSystemTools::GlobDirs(expanded, paths); + cmSystemTools::GlobDirs(expanded, outPaths); } } //---------------------------------------------------------------------------- -void cmFindCommon::AddCMakePath(const std::string& variable) +void cmFindCommon::AddCMakePath(const std::string& variable, + std::vector<std::string>& outPaths) { // Get a path from a CMake variable. if(const char* varPath = this->Makefile->GetDefinition(variable)) @@ -384,77 +399,83 @@ void cmFindCommon::AddCMakePath(const std::string& variable) // Relative paths are interpreted with respect to the current // source directory. - this->AddPathsInternal(tmp, CMakePath); + this->AddPathsInternal(tmp, CMakePath, outPaths); } } //---------------------------------------------------------------------------- -void cmFindCommon::AddEnvPath(const char* variable) +void cmFindCommon::AddEnvPath(const char* variable, + std::vector<std::string>& outPaths) { // Get a path from the environment. std::vector<std::string> tmp; cmSystemTools::GetPath(tmp, variable); // Relative paths are interpreted with respect to the current // working directory. - this->AddPathsInternal(tmp, EnvPath); + this->AddPathsInternal(tmp, EnvPath, outPaths); } //---------------------------------------------------------------------------- -void cmFindCommon::AddPathsInternal(std::vector<std::string> const& in_paths, - PathType pathType) +void cmFindCommon::AddPathsInternal(std::vector<std::string> const& inPaths, + PathType pathType, + std::vector<std::string>& outPaths) { - for(std::vector<std::string>::const_iterator i = in_paths.begin(); - i != in_paths.end(); ++i) + for(std::vector<std::string>::const_iterator i = inPaths.begin(); + i != inPaths.end(); ++i) { - this->AddPathInternal(*i, pathType); + this->AddPathInternal(this->MakeFullPath(*i, pathType), outPaths); } } //---------------------------------------------------------------------------- -void cmFindCommon::AddPathInternal(std::string const& in_path, - PathType pathType) +void cmFindCommon::AddPathInternal(std::string const& inPath, + std::vector<std::string>& outPaths) { - if(in_path.empty()) + if(inPath.empty()) { return; } - // Select the base path with which to interpret relative paths. - const char* relbase = 0; - if(pathType == CMakePath) - { - relbase = this->Makefile->GetCurrentDirectory(); - } - - // Convert to clean full path. - std::string fullPath = - cmSystemTools::CollapseFullPath(in_path, relbase); - // Insert the path if has not already been emitted. - if(this->SearchPathsEmitted.insert(fullPath).second) + if(this->SearchPathsEmitted.insert(inPath).second) { - this->SearchPaths.push_back(fullPath); + outPaths.push_back(inPath); } } //---------------------------------------------------------------------------- +void AddTrailingSlash(std::string& s) +{ + if(!s.empty() && *s.rbegin() != '/') + { + s += '/'; + } +} void cmFindCommon::ComputeFinalPaths() { - std::vector<std::string>& paths = this->SearchPaths; + // Filter out ignored paths from the prefix list + std::set<std::string> ignored; + this->GetIgnoredPaths(ignored); + + // Combine the seperate path types, filtering out ignores + this->SearchPaths.clear(); + this->FilterPaths(this->CMakeVariablePaths, ignored, this->SearchPaths); + this->FilterPaths(this->CMakeEnvironmentPaths, ignored, this->SearchPaths); + this->FilterPaths(this->UserHintsPaths, ignored, this->SearchPaths); + this->FilterPaths(this->SystemEnvironmentPaths, ignored, this->SearchPaths); + this->FilterPaths(this->UserRegistryPaths, ignored, this->SearchPaths); + this->FilterPaths(this->BuildPaths, ignored, this->SearchPaths); + this->FilterPaths(this->CMakeSystemVariablePaths, ignored, + this->SearchPaths); + this->FilterPaths(this->SystemRegistryPaths, ignored, this->SearchPaths); + this->FilterPaths(this->UserGuessPaths, ignored, this->SearchPaths); // Expand list of paths inside all search roots. - this->RerootPaths(paths); + this->RerootPaths(this->SearchPaths); // Add a trailing slash to all paths to aid the search process. - for(std::vector<std::string>::iterator i = paths.begin(); - i != paths.end(); ++i) - { - std::string& p = *i; - if(!p.empty() && p[p.size()-1] != '/') - { - p += "/"; - } - } + std::for_each(this->SearchPaths.begin(), this->SearchPaths.end(), + &AddTrailingSlash); } //---------------------------------------------------------------------------- diff --git a/Source/cmFindCommon.h b/Source/cmFindCommon.h index 5a905cd..dfb942f 100644 --- a/Source/cmFindCommon.h +++ b/Source/cmFindCommon.h @@ -36,6 +36,9 @@ protected: enum PathType { FullPath, CMakePath, EnvPath }; + /** Generate a full path based on the particular path type */ + std::string MakeFullPath(const std::string& path, PathType pathType); + /** Place a set of search paths under the search roots. */ void RerootPaths(std::vector<std::string>& paths); @@ -44,8 +47,9 @@ protected: void GetIgnoredPaths(std::set<std::string>& ignore); /** Remove paths in the ignore set from the supplied vector. */ - void FilterPaths(std::vector<std::string>& paths, - const std::set<std::string>& ignore); + void FilterPaths(const std::vector<std::string>& inPaths, + const std::set<std::string>& ignore, + std::vector<std::string>& outPaths); /** Compute final search path list (reroot + trailing slash). */ void ComputeFinalPaths(); @@ -62,12 +66,14 @@ protected: bool CheckCommonArgument(std::string const& arg); void AddPathSuffix(std::string const& arg); void AddUserPath(std::string const& p, - std::vector<std::string>& paths); - void AddCMakePath(const std::string& variable); - void AddEnvPath(const char* variable); - void AddPathsInternal(std::vector<std::string> const& in_paths, - PathType pathType); - void AddPathInternal(std::string const& in_path, PathType pathType); + std::vector<std::string>& outPaths); + void AddCMakePath(const std::string& variable, + std::vector<std::string>& outPaths); + void AddEnvPath(const char* variable, std::vector<std::string>& outPaths); + void AddPathsInternal(std::vector<std::string> const& inPaths, + PathType pathType, std::vector<std::string>& outPaths); + void AddPathInternal(std::string const& inPath, + std::vector<std::string>& outPaths); void SetMakefile(cmMakefile* makefile); @@ -78,8 +84,16 @@ protected: bool NoCMakeSystemPath; std::vector<std::string> SearchPathSuffixes; - std::vector<std::string> UserPaths; - std::vector<std::string> UserHints; + std::vector<std::string> CMakeVariablePaths; + std::vector<std::string> CMakeEnvironmentPaths; + std::vector<std::string> UserHintsPaths; + std::vector<std::string> SystemEnvironmentPaths; + std::vector<std::string> UserRegistryPaths; + std::vector<std::string> BuildPaths; + std::vector<std::string> CMakeSystemVariablePaths; + std::vector<std::string> SystemRegistryPaths; + std::vector<std::string> UserGuessPaths; + std::vector<std::string> SearchPaths; std::set<std::string> SearchPathsEmitted; diff --git a/Source/cmFindLibraryCommand.cxx b/Source/cmFindLibraryCommand.cxx index 16deaab..78f0e9e 100644 --- a/Source/cmFindLibraryCommand.cxx +++ b/Source/cmFindLibraryCommand.cxx @@ -88,7 +88,7 @@ void cmFindLibraryCommand::AddArchitecturePaths(const char* suffix) { std::vector<std::string> original; original.swap(this->SearchPaths); - for(std::vector<std::string>::iterator i = original.begin(); + for(std::vector<std::string>::const_iterator i = original.begin(); i != original.end(); ++i) { this->AddArchitecturePath(*i, 0, suffix); diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx index 4633e71..ded6eee 100644 --- a/Source/cmFindPackageCommand.cxx +++ b/Source/cmFindPackageCommand.cxx @@ -248,11 +248,11 @@ bool cmFindPackageCommand } else if(doing == DoingPaths) { - this->AddUserPath(args[i], this->UserPaths); + this->AddUserPath(args[i], this->UserGuessPaths); } else if(doing == DoingHints) { - this->AddUserPath(args[i], this->UserHints); + this->AddUserPath(args[i], this->UserHintsPaths); } else if(doing == DoingPathSuffixes) { @@ -1111,86 +1111,99 @@ void cmFindPackageCommand::AppendSuccessInformation() //---------------------------------------------------------------------------- void cmFindPackageCommand::ComputePrefixes() { - this->AddPrefixesCMakeVariable(); - this->AddPrefixesCMakeEnvironment(); - this->AddPrefixesUserHints(); - this->AddPrefixesSystemEnvironment(); - this->AddPrefixesUserRegistry(); - this->AddPrefixesBuilds(); - this->AddPrefixesCMakeSystemVariable(); - this->AddPrefixesSystemRegistry(); - this->AddPrefixesUserGuess(); + if(!this->NoDefaultPath) + { + if(!this->NoCMakePath) + { + this->FillPrefixesCMakeVariable(); + } + if(!this->NoCMakeEnvironmentPath) + { + this->FillPrefixesCMakeEnvironment(); + } + if(!this->NoSystemEnvironmentPath) + { + this->FillPrefixesSystemEnvironment(); + } + if(!this->NoUserRegistry) + { + this->FillPrefixesUserRegistry(); + } + if(!this->NoBuilds) + { + this->FillPrefixesBuilds(); + } + if(!this->NoCMakeSystemPath) + { + this->FillPrefixesCMakeSystemVariable(); + } + if(!this->NoSystemRegistry) + { + this->FillPrefixesSystemRegistry(); + } + } + this->FillPrefixesUserHints(); + this->FillPrefixesUserGuess(); + this->ComputeFinalPaths(); } //---------------------------------------------------------------------------- -void cmFindPackageCommand::AddPrefixesCMakeEnvironment() +void cmFindPackageCommand::FillPrefixesCMakeEnvironment() { - if(!this->NoCMakeEnvironmentPath && !this->NoDefaultPath) + // Check the environment variable with the same name as the cache + // entry. + std::string env; + if(cmSystemTools::GetEnv(this->Variable.c_str(), env) && env.length() > 0) { - // Check the environment variable with the same name as the cache - // entry. - std::string env; - if(cmSystemTools::GetEnv(this->Variable.c_str(), env) && env.length() > 0) - { - cmSystemTools::ConvertToUnixSlashes(env); - this->AddPathInternal(env, EnvPath); - } - - this->AddEnvPath("CMAKE_PREFIX_PATH"); - this->AddEnvPath("CMAKE_FRAMEWORK_PATH"); - this->AddEnvPath("CMAKE_APPBUNDLE_PATH"); + cmSystemTools::ConvertToUnixSlashes(env); + this->AddPathInternal(MakeFullPath(env, EnvPath), + this->CMakeEnvironmentPaths); } + + this->AddEnvPath("CMAKE_PREFIX_PATH", this->CMakeEnvironmentPaths); + this->AddEnvPath("CMAKE_FRAMEWORK_PATH", this->CMakeEnvironmentPaths); + this->AddEnvPath("CMAKE_APPBUNDLE_PATH", this->CMakeEnvironmentPaths); } //---------------------------------------------------------------------------- -void cmFindPackageCommand::AddPrefixesCMakeVariable() +void cmFindPackageCommand::FillPrefixesCMakeVariable() { - if(!this->NoCMakePath && !this->NoDefaultPath) - { - this->AddCMakePath("CMAKE_PREFIX_PATH"); - this->AddCMakePath("CMAKE_FRAMEWORK_PATH"); - this->AddCMakePath("CMAKE_APPBUNDLE_PATH"); - } + this->AddCMakePath("CMAKE_PREFIX_PATH", this->CMakeVariablePaths); + this->AddCMakePath("CMAKE_FRAMEWORK_PATH", this->CMakeVariablePaths); + this->AddCMakePath("CMAKE_APPBUNDLE_PATH", this->CMakeVariablePaths); } //---------------------------------------------------------------------------- -void cmFindPackageCommand::AddPrefixesSystemEnvironment() +void cmFindPackageCommand::FillPrefixesSystemEnvironment() { - if(!this->NoSystemEnvironmentPath && !this->NoDefaultPath) - { - // Use the system search path to generate prefixes. - // Relative paths are interpreted with respect to the current - // working directory. - std::vector<std::string> tmp; - cmSystemTools::GetPath(tmp); - for(std::vector<std::string>::iterator i = tmp.begin(); - i != tmp.end(); ++i) + // Use the system search path to generate prefixes. + // Relative paths are interpreted with respect to the current + // working directory. + std::vector<std::string> tmp; + cmSystemTools::GetPath(tmp); + for(std::vector<std::string>::iterator i = tmp.begin(); + i != tmp.end(); ++i) + { + // If the path is a PREFIX/bin case then add its parent instead. + if((cmHasLiteralSuffix(*i, "/bin")) || + (cmHasLiteralSuffix(*i, "/sbin"))) + { + this->AddPathInternal(MakeFullPath(cmSystemTools::GetFilenamePath(*i), + EnvPath), + this->SystemEnvironmentPaths); + } + else { - std::string const& d = *i; - - // If the path is a PREFIX/bin case then add its parent instead. - if((cmHasLiteralSuffix(d, "/bin")) || - (cmHasLiteralSuffix(d, "/sbin"))) - { - this->AddPathInternal(cmSystemTools::GetFilenamePath(d), EnvPath); - } - else - { - this->AddPathInternal(d, EnvPath); - } + this->AddPathInternal(MakeFullPath(*i, EnvPath), + this->SystemEnvironmentPaths); } } } //---------------------------------------------------------------------------- -void cmFindPackageCommand::AddPrefixesUserRegistry() +void cmFindPackageCommand::FillPrefixesUserRegistry() { - if(this->NoUserRegistry || this->NoDefaultPath) - { - return; - } - #if defined(_WIN32) && !defined(__CYGWIN__) this->LoadPackageRegistryWinUser(); #elif defined(__HAIKU__) @@ -1201,7 +1214,7 @@ void cmFindPackageCommand::AddPrefixesUserRegistry() std::string fname = dir; fname += "/cmake/packages/"; fname += Name; - this->LoadPackageRegistryDir(fname); + this->LoadPackageRegistryDir(fname, this->UserRegistryPaths); } #else if(const char* home = cmSystemTools::GetEnv("HOME")) @@ -1209,13 +1222,13 @@ void cmFindPackageCommand::AddPrefixesUserRegistry() std::string dir = home; dir += "/.cmake/packages/"; dir += this->Name; - this->LoadPackageRegistryDir(dir); + this->LoadPackageRegistryDir(dir, this->UserRegistryPaths); } #endif } //---------------------------------------------------------------------------- -void cmFindPackageCommand::AddPrefixesSystemRegistry() +void cmFindPackageCommand::FillPrefixesSystemRegistry() { if(this->NoSystemRegistry || this->NoDefaultPath) { @@ -1241,7 +1254,7 @@ void cmFindPackageCommand::AddPrefixesSystemRegistry() void cmFindPackageCommand::LoadPackageRegistryWinUser() { // HKEY_CURRENT_USER\\Software shares 32-bit and 64-bit views. - this->LoadPackageRegistryWin(true, 0); + this->LoadPackageRegistryWin(true, 0, this->UserRegistryPaths); } //---------------------------------------------------------------------------- @@ -1251,19 +1264,23 @@ void cmFindPackageCommand::LoadPackageRegistryWinSystem() // Prefer the target platform view first. if(this->Makefile->PlatformIs64Bit()) { - this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY); - this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY); + this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY, + this->SystemRegistryPaths); + this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY, + this->SystemRegistryPaths); } else { - this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY); - this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY); + this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY, + this->SystemRegistryPaths); + this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY, + this->SystemRegistryPaths); } } //---------------------------------------------------------------------------- -void cmFindPackageCommand::LoadPackageRegistryWin(bool user, - unsigned int view) +void cmFindPackageCommand::LoadPackageRegistryWin(bool user, unsigned int view, + std::vector<std::string>& outPaths) { std::wstring key = L"Software\\Kitware\\CMake\\Packages\\"; key += cmsys::Encoding::ToWide(this->Name); @@ -1289,8 +1306,8 @@ void cmFindPackageCommand::LoadPackageRegistryWin(bool user, if(valueType == REG_SZ) { data[dataSize] = 0; - cmsys_ios::stringstream ss(cmsys::Encoding::ToNarrow(&data[0])); - if(!this->CheckPackageRegistryEntry(ss)) + if(!this->CheckPackageRegistryEntry( + cmsys::Encoding::ToNarrow(&data[0]), outPaths)) { // The entry is invalid. bad.insert(name); @@ -1332,7 +1349,8 @@ public: }; //---------------------------------------------------------------------------- -void cmFindPackageCommand::LoadPackageRegistryDir(std::string const& dir) +void cmFindPackageCommand::LoadPackageRegistryDir(std::string const& dir, + std::vector<std::string>& outPaths) { cmsys::Directory files; if(!files.Load(dir)) @@ -1354,7 +1372,9 @@ void cmFindPackageCommand::LoadPackageRegistryDir(std::string const& dir) // Load the file. cmsys::ifstream fin(fname.c_str(), std::ios::in | cmsys_ios_binary); - if(fin && this->CheckPackageRegistryEntry(fin)) + std::string fentry; + if(fin && cmSystemTools::GetLineFromStream(fin, fentry) && + this->CheckPackageRegistryEntry(fentry, outPaths)) { // The file references an existing package, so release it. holdFile.Release(); @@ -1367,12 +1387,11 @@ void cmFindPackageCommand::LoadPackageRegistryDir(std::string const& dir) #endif //---------------------------------------------------------------------------- -bool cmFindPackageCommand::CheckPackageRegistryEntry(std::istream& is) +bool cmFindPackageCommand::CheckPackageRegistryEntry(const std::string& fname, + std::vector<std::string>& outPaths) { // Parse the content of one package registry entry. - std::string fname; - if(cmSystemTools::GetLineFromStream(is, fname) && - cmSystemTools::FileIsFullPath(fname.c_str())) + if(cmSystemTools::FileIsFullPath(fname.c_str())) { // The first line in the stream is the full path to a file or // directory containing the package. @@ -1381,9 +1400,14 @@ bool cmFindPackageCommand::CheckPackageRegistryEntry(std::istream& is) // The path exists. Look for the package here. if(!cmSystemTools::FileIsDirectory(fname)) { - fname = cmSystemTools::GetFilenamePath(fname); + this->AddPathInternal( + MakeFullPath(cmSystemTools::GetFilenamePath(fname), FullPath), + outPaths); + } + else + { + this->AddPathInternal(MakeFullPath(fname, FullPath), outPaths); } - this->AddPathInternal(fname, FullPath); return true; } else @@ -1404,52 +1428,51 @@ bool cmFindPackageCommand::CheckPackageRegistryEntry(std::istream& is) } //---------------------------------------------------------------------------- -void cmFindPackageCommand::AddPrefixesBuilds() +void cmFindPackageCommand::FillPrefixesBuilds() { - if(!this->NoBuilds && !this->NoDefaultPath) - { - // It is likely that CMake will have recently built the project. - for(int i=0; i <= 10; ++i) - { - cmOStringStream r; - r << - "[HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\" - "Settings\\StartPath;WhereBuild" << i << "]"; - std::string f = r.str(); - cmSystemTools::ExpandRegistryValues(f); - cmSystemTools::ConvertToUnixSlashes(f); - if(cmSystemTools::FileIsFullPath(f.c_str()) && - cmSystemTools::FileIsDirectory(f)) - { - this->AddPathInternal(f, FullPath); - } + // It is likely that CMake will have recently built the project. + for(int i=0; i <= 10; ++i) + { + cmOStringStream r; + r << + "[HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\" + "Settings\\StartPath;WhereBuild" << i << "]"; + std::string f = r.str(); + cmSystemTools::ExpandRegistryValues(f); + cmSystemTools::ConvertToUnixSlashes(f); + if(cmSystemTools::FileIsFullPath(f.c_str()) && + cmSystemTools::FileIsDirectory(f.c_str())) + { + this->AddPathInternal(MakeFullPath(f, FullPath), this->BuildPaths); } } } //---------------------------------------------------------------------------- -void cmFindPackageCommand::AddPrefixesCMakeSystemVariable() +void cmFindPackageCommand::FillPrefixesCMakeSystemVariable() { - if(!this->NoCMakeSystemPath && !this->NoDefaultPath) - { - this->AddCMakePath("CMAKE_SYSTEM_PREFIX_PATH"); - this->AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH"); - this->AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH"); - } + this->AddCMakePath("CMAKE_SYSTEM_PREFIX_PATH", + this->CMakeSystemVariablePaths); + this->AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH", + this->CMakeSystemVariablePaths); + this->AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH", + this->CMakeSystemVariablePaths); } //---------------------------------------------------------------------------- -void cmFindPackageCommand::AddPrefixesUserGuess() +void cmFindPackageCommand::FillPrefixesUserGuess() { - // Add guesses specified by the caller. - this->AddPathsInternal(this->UserPaths, CMakePath); + std::vector<std::string> inPaths; + inPaths.swap(this->UserGuessPaths); + this->AddPathsInternal(inPaths, CMakePath, this->UserGuessPaths); } //---------------------------------------------------------------------------- -void cmFindPackageCommand::AddPrefixesUserHints() +void cmFindPackageCommand::FillPrefixesUserHints() { - // Add hints specified by the caller. - this->AddPathsInternal(this->UserHints, CMakePath); + std::vector<std::string> inPaths; + inPaths.swap(this->UserHintsPaths); + this->AddPathsInternal(inPaths, CMakePath, this->UserHintsPaths); } //---------------------------------------------------------------------------- diff --git a/Source/cmFindPackageCommand.h b/Source/cmFindPackageCommand.h index 2249459..f22433e 100644 --- a/Source/cmFindPackageCommand.h +++ b/Source/cmFindPackageCommand.h @@ -69,20 +69,23 @@ private: void StoreVersionFound(); void ComputePrefixes(); - void AddPrefixesCMakeEnvironment(); - void AddPrefixesCMakeVariable(); - void AddPrefixesSystemEnvironment(); - void AddPrefixesUserRegistry(); - void AddPrefixesSystemRegistry(); - void AddPrefixesBuilds(); - void AddPrefixesCMakeSystemVariable(); - void AddPrefixesUserGuess(); - void AddPrefixesUserHints(); - void LoadPackageRegistryDir(std::string const& dir); + void FillPrefixesCMakeEnvironment(); + void FillPrefixesCMakeVariable(); + void FillPrefixesSystemEnvironment(); + void FillPrefixesUserRegistry(); + void FillPrefixesSystemRegistry(); + void FillPrefixesBuilds(); + void FillPrefixesCMakeSystemVariable(); + void FillPrefixesUserGuess(); + void FillPrefixesUserHints(); + void LoadPackageRegistryDir(std::string const& dir, + std::vector<std::string>& outPaths); void LoadPackageRegistryWinUser(); void LoadPackageRegistryWinSystem(); - void LoadPackageRegistryWin(bool user, unsigned int view); - bool CheckPackageRegistryEntry(std::istream& is); + void LoadPackageRegistryWin(bool user, unsigned int view, + std::vector<std::string>& outPaths); + bool CheckPackageRegistryEntry(const std::string& fname, + std::vector<std::string>& outPaths); bool SearchDirectory(std::string const& dir); bool CheckDirectory(std::string const& dir); bool FindConfigFile(std::string const& dir, std::string& file); |