diff options
| -rw-r--r-- | Source/cmBootstrapCommands.cxx | 1 | ||||
| -rw-r--r-- | Source/cmFindBase.cxx | 386 | ||||
| -rw-r--r-- | Source/cmFindBase.h | 34 | ||||
| -rw-r--r-- | Source/cmFindCommon.cxx | 479 | ||||
| -rw-r--r-- | Source/cmFindCommon.h | 95 | ||||
| -rw-r--r-- | Source/cmFindLibraryCommand.cxx | 6 | ||||
| -rw-r--r-- | Source/cmFindPackageCommand.cxx | 1354 | ||||
| -rw-r--r-- | Source/cmFindPackageCommand.h | 78 | ||||
| -rw-r--r-- | Source/cmFindPathCommand.cxx | 6 | ||||
| -rw-r--r-- | Source/cmFindProgramCommand.cxx | 6 |
10 files changed, 1853 insertions, 592 deletions
diff --git a/Source/cmBootstrapCommands.cxx b/Source/cmBootstrapCommands.cxx index 5075c61a22..77adce5d45 100644 --- a/Source/cmBootstrapCommands.cxx +++ b/Source/cmBootstrapCommands.cxx @@ -42,6 +42,7 @@ #include "cmExecProgramCommand.cxx" #include "cmExternalMakefileProjectGenerator.cxx" #include "cmFindBase.cxx" +#include "cmFindCommon.cxx" #include "cmFileCommand.cxx" #include "cmFindFileCommand.cxx" #include "cmFindLibraryCommand.cxx" diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx index d8e218d4a4..63a589b8ca 100644 --- a/Source/cmFindBase.cxx +++ b/Source/cmFindBase.cxx @@ -18,26 +18,10 @@ cmFindBase::cmFindBase() { + cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder, + "FIND_ARGS_XXX", "<VAR> NAMES name"); this->AlreadyInCache = false; this->AlreadyInCacheWithoutMetaInfo = false; - this->NoDefaultPath = false; - this->NoCMakePath = false; - this->NoCMakeEnvironmentPath = false; - this->NoSystemEnvironmentPath = false; - this->NoCMakeSystemPath = false; - this->FindRootPathMode = RootPathModeBoth; - // default is to search frameworks first on apple -#if defined(__APPLE__) - this->SearchFrameworkFirst = true; - this->SearchAppBundleFirst = true; -#else - this->SearchFrameworkFirst = false; - this->SearchAppBundleFirst = false; -#endif - this->SearchFrameworkOnly = false; - this->SearchFrameworkLast = false; - this->SearchAppBundleOnly = false; - this->SearchAppBundleLast = false; this->GenericDocumentation = " FIND_XXX(<VAR> name1 path1 path2 ...)\n" "This is the short-hand signature for the command that " @@ -54,8 +38,9 @@ cmFindBase::cmFindBase() " [NO_CMAKE_PATH]\n" " [NO_SYSTEM_ENVIRONMENT_PATH]\n" " [NO_CMAKE_SYSTEM_PATH]\n" - " [CMAKE_FIND_ROOT_PATH_BOTH | ONLY_CMAKE_FIND_ROOT_PATH | " - "NO_CMAKE_FIND_ROOT_PATH ]\n" + " [CMAKE_FIND_ROOT_PATH_BOTH |\n" + " ONLY_CMAKE_FIND_ROOT_PATH |\n" + " NO_CMAKE_FIND_ROOT_PATH]\n" " )\n" "" "This command is used to find a SEARCH_XXX_DESC. " @@ -84,9 +69,8 @@ cmFindBase::cmFindBase() "can be skipped if NO_CMAKE_ENVIRONMENT_PATH is passed.\n" "" " <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_PREFIX_PATH\n" - " CMAKE_FRAMEWORK_PATH\n" - " CMAKE_APPBUNDLE_PATH\n" " CMAKE_XXX_PATH\n" + " CMAKE_XXX_MAC_PATH\n" "2. Search cmake variables with the same names as " "the cmake specific environment variables. These " "are intended to be used on the command line with a " @@ -94,9 +78,8 @@ cmFindBase::cmFindBase() "is passed.\n" "" " <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_PREFIX_PATH\n" - " CMAKE_FRAMEWORK_PATH\n" - " CMAKE_APPBUNDLE_PATH\n" " CMAKE_XXX_PATH\n" + " CMAKE_XXX_MAC_PATH\n" "3. Search the standard system environment variables. " "This can be skipped if NO_SYSTEM_ENVIRONMENT_PATH is an argument.\n" " PATH\n" @@ -105,51 +88,14 @@ cmFindBase::cmFindBase() "for the current system. This can be skipped if NO_CMAKE_SYSTEM_PATH " "is passed.\n" " <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH\n" - " CMAKE_SYSTEM_FRAMEWORK_PATH\n" - " CMAKE_SYSTEM_APPBUNDLE_PATH\n" " CMAKE_SYSTEM_XXX_PATH\n" + " CMAKE_SYSTEM_XXX_MAC_PATH\n" "5. Search the paths specified after PATHS or in the short-hand version " "of the command.\n" - "On Darwin or systems supporting OSX Frameworks, the cmake variable" - " CMAKE_FIND_FRAMEWORK can be set to empty or one of the following:\n" - " \"FIRST\" - Try to find frameworks before standard\n" - " libraries or headers. This is the default on Darwin.\n" - " \"LAST\" - Try to find frameworks after standard\n" - " libraries or headers.\n" - " \"ONLY\" - Only try to find frameworks.\n" - " \"NEVER\". - Never try to find frameworks.\n" - "On Darwin or systems supporting OSX Application Bundles, the cmake " - "variable CMAKE_FIND_APPBUNDLE can be set to empty or one of the " - "following:\n" - " \"FIRST\" - Try to find application bundles before standard\n" - " programs. This is the default on Darwin.\n" - " \"LAST\" - Try to find application bundles after standard\n" - " programs.\n" - " \"ONLY\" - Only try to find application bundles.\n" - " \"NEVER\". - Never try to find application bundles.\n" - "The CMake variable CMAKE_FIND_ROOT_PATH specifies one or more " - "directories to be prepended to all other search directories. " - "This effectively \"re-roots\" the entire search under given locations. " - "By default it is empty. It is especially useful when " - "cross-compiling to point to the root directory of the " - "target environment and CMake will search there too. By default at first " - "the directories listed in CMAKE_FIND_ROOT_PATH and then the non-rooted " - "directories will be searched. " - "The default behavior can be adjusted by setting " - "CMAKE_FIND_ROOT_PATH_MODE_XXX. This behavior can be manually " - "overridden on a per-call basis. " - "By using CMAKE_FIND_ROOT_PATH_BOTH the search order will " - "be as described above. If NO_CMAKE_FIND_ROOT_PATH is used " - "then CMAKE_FIND_ROOT_PATH will not be used. If ONLY_CMAKE_FIND_ROOT_PATH " - "is used then only the re-rooted directories will be searched.\n" - "The reason the paths listed in the call to the command are searched " - "last is that most users of CMake would expect things to be found " - "first in the locations specified by their environment. Projects may " - "override this behavior by simply calling the command twice:\n" - " FIND_XXX(<VAR> NAMES name PATHS paths NO_DEFAULT_PATH)\n" - " FIND_XXX(<VAR> NAMES name)\n" - "Once one of these calls succeeds the result variable will be set " - "and stored in the cache so that neither call will search again."; + ; + this->GenericDocumentation += this->GenericDocumentationMacPolicy; + this->GenericDocumentation += this->GenericDocumentationRootPath; + this->GenericDocumentation += this->GenericDocumentationPathsOrder; } bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn) @@ -159,57 +105,6 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn) this->SetError("called with incorrect number of arguments"); return false; } - std::string ff = this->Makefile->GetSafeDefinition("CMAKE_FIND_FRAMEWORK"); - if(ff == "NEVER") - { - this->SearchFrameworkLast = false; - this->SearchFrameworkFirst = false; - this->SearchFrameworkOnly = false; - } - else if (ff == "ONLY") - { - this->SearchFrameworkLast = false; - this->SearchFrameworkFirst = false; - this->SearchFrameworkOnly = true; - } - else if (ff == "FIRST") - { - this->SearchFrameworkLast = false; - this->SearchFrameworkFirst = true; - this->SearchFrameworkOnly = false; - } - else if (ff == "LAST") - { - this->SearchFrameworkLast = true; - this->SearchFrameworkFirst = false; - this->SearchFrameworkOnly = false; - } - - std::string fab = this->Makefile->GetSafeDefinition("CMAKE_FIND_APPBUNDLE"); - if(fab == "NEVER") - { - this->SearchAppBundleLast = false; - this->SearchAppBundleFirst = false; - this->SearchAppBundleOnly = false; - } - else if (fab == "ONLY") - { - this->SearchAppBundleLast = false; - this->SearchAppBundleFirst = false; - this->SearchAppBundleOnly = true; - } - else if (fab == "FIRST") - { - this->SearchAppBundleLast = false; - this->SearchAppBundleFirst = true; - this->SearchAppBundleOnly = false; - } - else if (fab == "LAST") - { - this->SearchAppBundleLast = true; - this->SearchAppBundleFirst = false; - this->SearchAppBundleOnly = false; - } // CMake versions below 2.3 did not search all these extra // locations. Preserve compatibility unless a modern argument is @@ -271,23 +166,12 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn) return true; } this->AlreadyInCache = false; - - std::string findRootPathVar = "CMAKE_FIND_ROOT_PATH_MODE_"; - findRootPathVar += this->CMakePathName; - std::string rootPathMode = - this->Makefile->GetSafeDefinition(findRootPathVar.c_str()); - if (rootPathMode=="NEVER") - { - this->FindRootPathMode = RootPathModeNoRootPath; - } - else if (rootPathMode=="ONLY") - { - this->FindRootPathMode = RootPathModeOnlyRootPath; - } - else if (rootPathMode=="BOTH") - { - this->FindRootPathMode = RootPathModeBoth; - } + + // Find the current root path mode. + this->SelectDefaultRootPathMode(); + + // Find the current bundle/framework search policy. + this->SelectDefaultMacMode(); std::vector<std::string> userPaths; std::string doc; @@ -327,60 +211,12 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn) doingNames = false; this->NoDefaultPath = true; } - else if (args[j] == "NO_DEFAULT_PATH") - { - compatibility = false; - doingPaths = false; - doingPathSuf = false; - doingNames = false; - this->NoDefaultPath = true; - } - else if (args[j] == "NO_CMAKE_ENVIRONMENT_PATH") - { - compatibility = false; - doingPaths = false; - doingPathSuf = false; - doingNames = false; - this->NoCMakeEnvironmentPath = true; - } - else if (args[j] == "NO_CMAKE_PATH") - { - compatibility = false; - doingPaths = false; - doingPathSuf = false; - doingNames = false; - this->NoCMakePath = true; - } - else if (args[j] == "NO_SYSTEM_ENVIRONMENT_PATH") - { - compatibility = false; - doingPaths = false; - doingPathSuf = false; - doingNames = false; - this->NoSystemEnvironmentPath = true; - } - else if (args[j] == "NO_CMAKE_SYSTEM_PATH") + else if (this->CheckCommonArgument(args[j])) { compatibility = false; doingPaths = false; doingPathSuf = false; doingNames = false; - this->NoCMakeSystemPath = true; - } - else if (args[j] == "NO_CMAKE_FIND_ROOT_PATH") - { - compatibility = false; - this->FindRootPathMode = RootPathModeNoRootPath; - } - else if (args[j] == "ONLY_CMAKE_FIND_ROOT_PATH") - { - compatibility = false; - this->FindRootPathMode = RootPathModeOnlyRootPath; - } - else if (args[j] == "CMAKE_FIND_ROOT_PATH_BOTH") - { - compatibility = false; - this->FindRootPathMode = RootPathModeBoth; } else { @@ -393,8 +229,8 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn) userPaths.push_back(args[j]); } else if(doingPathSuf) - { - this->SearchPathSuffixes.push_back(args[j]); + { + this->AddPathSuffix(args[j]); } } } @@ -446,8 +282,9 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn) } } this->ExpandPaths(userPaths); - - this->HandleCMakeFindRootPath(); + + // Handle search root stuff. + this->RerootPaths(this->SearchPaths); return true; } @@ -457,11 +294,11 @@ void cmFindBase::ExpandPaths(std::vector<std::string> userPaths) // standard search paths. if(!this->NoDefaultPath) { - if(this->SearchFrameworkFirst) + if(this->SearchFrameworkFirst || this->SearchFrameworkOnly) { this->AddFrameWorkPaths(); } - if(this->SearchAppBundleFirst) + if(this->SearchAppBundleFirst || this->SearchAppBundleOnly) { this->AddAppBundlePaths(); } @@ -509,55 +346,7 @@ void cmFindBase::ExpandPaths(std::vector<std::string> userPaths) this->AddPaths(paths); } -void cmFindBase::HandleCMakeFindRootPath() -{ - if (this->FindRootPathMode == RootPathModeNoRootPath) - { - return; - } - - const char* rootPath = this->Makefile->GetDefinition("CMAKE_FIND_ROOT_PATH"); - if ((rootPath == 0) || (strlen(rootPath) == 0)) - { - return; - } - - std::vector<std::string> roots; - cmSystemTools::ExpandListArgument(rootPath, roots); - - std::vector<std::string> unrootedPaths=this->SearchPaths; - this->SearchPaths.clear(); - - for (std::vector<std::string>::const_iterator rootIt = roots.begin(); - rootIt != roots.end(); - ++rootIt ) - { - for (std::vector<std::string>::const_iterator it = unrootedPaths.begin(); - it != unrootedPaths.end(); - ++it ) - { - // if the current directory is already inside the current root, don't - // add the root again - std::string rootedDir; - if (cmSystemTools::IsSubDirectory(it->c_str(), rootIt->c_str())) - { - rootedDir = *it; - } - else - { - rootedDir=*rootIt; - rootedDir+=*it; - } - this->SearchPaths.push_back(rootedDir); - } - } - - if (this->FindRootPathMode == RootPathModeBoth) - { - this->AddPaths(unrootedPaths); - } -} - +//---------------------------------------------------------------------------- void cmFindBase::AddEnvironmentVariables() { std::vector<std::string> paths; @@ -570,14 +359,6 @@ void cmFindBase::AddEnvironmentVariables() var += this->CMakePathName; var += "_PATH"; cmSystemTools::GetPath(paths, var.c_str()); - if(this->SearchAppBundleLast) - { - cmSystemTools::GetPath(paths, "CMAKE_APPBUNDLE_PATH"); - } - if(this->SearchFrameworkLast) - { - cmSystemTools::GetPath(paths, "CMAKE_FRAMEWORK_PATH"); - } this->AddPaths(paths); } @@ -585,15 +366,15 @@ void cmFindBase::AddFindPrefix(std::vector<std::string>& dest, const std::vector<std::string>& src) { // default for programs - std::string subdir = "/bin"; + std::string subdir = "bin"; if (this->CMakePathName == "INCLUDE") { - subdir = "/include"; + subdir = "include"; } else if (this->CMakePathName == "LIBRARY") { - subdir = "/lib"; + subdir = "lib"; } else if (this->CMakePathName == "FRAMEWORK") { @@ -604,14 +385,15 @@ void cmFindBase::AddFindPrefix(std::vector<std::string>& dest, it != src.end(); ++it) { - std::string dirWithSubdir = it->c_str(); - dirWithSubdir += subdir; - dest.push_back(dirWithSubdir); - if (subdir == "/bin") + std::string dir = it->c_str(); + if(!subdir.empty() && !dir.empty() && dir[dir.size()-1] != '/') + { + dir += "/"; + } + dest.push_back(dir + subdir); + if (subdir == "bin") { - dirWithSubdir = it->c_str(); - dirWithSubdir += "/sbin"; - dest.push_back(dirWithSubdir); + dest.push_back(dir + "sbin"); } if(!subdir.empty()) { @@ -622,35 +404,9 @@ void cmFindBase::AddFindPrefix(std::vector<std::string>& dest, void cmFindBase::AddFrameWorkPaths() { - if(this->NoDefaultPath) - { - return; - } std::vector<std::string> paths; - // first environment variables - if(!this->NoCMakeEnvironmentPath) - { - cmSystemTools::GetPath(paths, "CMAKE_FRAMEWORK_PATH"); - } - // add cmake variables - if(!this->NoCMakePath) - { - if(const char* path = - this->Makefile->GetDefinition("CMAKE_FRAMEWORK_PATH")) - { - cmSystemTools::ExpandListArgument(path, paths); - } - } - // AddCMakeSystemVariables - if(!this->NoCMakeSystemPath) - { - if(const char* path = - this->Makefile->GetDefinition("CMAKE_SYSTEM_FRAMEWORK_PATH")) - { - cmSystemTools::ExpandListArgument(path, paths); - } - } - this->AddPaths(paths); + this->GetFrameworkPaths(paths); + this->AddPaths(paths); } void cmFindBase::AddPaths(std::vector<std::string> & paths) @@ -665,35 +421,9 @@ void cmFindBase::AddPaths(std::vector<std::string> & paths) void cmFindBase::AddAppBundlePaths() { - if(this->NoDefaultPath) - { - return; - } std::vector<std::string> paths; - // first environment variables - if(!this->NoCMakeEnvironmentPath) - { - cmSystemTools::GetPath(paths, "CMAKE_APPBUNDLE_PATH"); - } - // add cmake variables - if(!this->NoCMakePath) - { - if(const char* path = - this->Makefile->GetDefinition("CMAKE_APPBUNDLE_PATH")) - { - cmSystemTools::ExpandListArgument(path, paths); - } - } - // AddCMakeSystemVariables - if(!this->NoCMakeSystemPath) - { - if(const char* path = - this->Makefile->GetDefinition("CMAKE_SYSTEM_APPBUNDLE_PATH")) - { - cmSystemTools::ExpandListArgument(path, paths); - } - } - this->AddPaths(paths); + this->GetAppBundlePaths(paths); + this->AddPaths(paths); } void cmFindBase::AddCMakeVariables() @@ -715,22 +445,6 @@ void cmFindBase::AddCMakeVariables() { cmSystemTools::ExpandListArgument(path, paths); } - if(this->SearchAppBundleLast) - { - if(const char* path = - this->Makefile->GetDefinition("CMAKE_APPBUNDLE_PATH")) - { - cmSystemTools::ExpandListArgument(path, paths); - } - } - if(this->SearchFrameworkLast) - { - if(const char* path = - this->Makefile->GetDefinition("CMAKE_FRAMEWORK_PATH")) - { - cmSystemTools::ExpandListArgument(path, paths); - } - } this->AddPaths(paths); } @@ -764,22 +478,6 @@ void cmFindBase::AddCMakeSystemVariables() { cmSystemTools::ExpandListArgument(path, paths); } - if(this->SearchAppBundleLast) - { - if(const char* path = - this->Makefile->GetDefinition("CMAKE_SYSTEM_APPBUNDLE_PATH")) - { - cmSystemTools::ExpandListArgument(path, paths); - } - } - if(this->SearchFrameworkLast) - { - if(const char* path = - this->Makefile->GetDefinition("CMAKE_SYSTEM_FRAMEWORK_PATH")) - { - cmSystemTools::ExpandListArgument(path, paths); - } - } this->AddPaths(paths); } diff --git a/Source/cmFindBase.h b/Source/cmFindBase.h index 5efbe2ad14..86a76f75ad 100644 --- a/Source/cmFindBase.h +++ b/Source/cmFindBase.h @@ -17,15 +17,15 @@ #ifndef cmFindBase_h #define cmFindBase_h -#include "cmCommand.h" +#include "cmFindCommon.h" /** \class cmFindBase - * \brief Define a command to search for an executable program. + * \brief Base class for most FIND_XXX commands. * * cmFindBase is a parent class for cmFindProgramCommand, cmFindPathCommand, - * and cmFindLibraryCommand, cmFindFile + * and cmFindLibraryCommand, cmFindFileCommand */ -class cmFindBase : public cmCommand +class cmFindBase : public cmFindCommon { public: cmFindBase(); @@ -34,20 +34,15 @@ public: * the CMakeLists.txt file. */ virtual bool ParseArguments(std::vector<std::string> const& args); - cmTypeMacro(cmFindBase, cmCommand); + cmTypeMacro(cmFindBase, cmFindCommon); virtual const char* GetFullDocumentation() {return this->GenericDocumentation.c_str();} - enum RootPathMode { RootPathModeBoth, - RootPathModeOnlyRootPath, - RootPathModeNoRootPath }; - protected: void PrintFindStuff(); void ExpandPaths(std::vector<std::string> userPaths); - void HandleCMakeFindRootPath(); - + // add to the SearchPaths void AddPaths(std::vector<std::string>& paths); void AddFrameWorkPaths(); @@ -70,29 +65,12 @@ protected: cmStdString VariableName; std::vector<std::string> Names; std::vector<std::string> SearchPaths; - std::vector<std::string> SearchPathSuffixes; // CMAKE_*_PATH CMAKE_SYSTEM_*_PATH FRAMEWORK|LIBRARY|INCLUDE|PROGRAM - cmStdString CMakePathName; cmStdString EnvironmentPath; // LIB,INCLUDE bool AlreadyInCache; bool AlreadyInCacheWithoutMetaInfo; - bool NoDefaultPath; - bool NoCMakePath; - bool NoCMakeEnvironmentPath; - bool NoSystemEnvironmentPath; - bool NoCMakeSystemPath; - RootPathMode FindRootPathMode; - - bool SearchFrameworkFirst; - bool SearchFrameworkOnly; - bool SearchFrameworkLast; - - bool SearchAppBundleFirst; - bool SearchAppBundleOnly; - bool SearchAppBundleLast; - }; diff --git a/Source/cmFindCommon.cxx b/Source/cmFindCommon.cxx new file mode 100644 index 0000000000..0c6af0daf7 --- /dev/null +++ b/Source/cmFindCommon.cxx @@ -0,0 +1,479 @@ +/*========================================================================= + + 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 "cmFindCommon.h" + +//---------------------------------------------------------------------------- +cmFindCommon::cmFindCommon() +{ + this->FindRootPathMode = RootPathModeBoth; + this->NoDefaultPath = false; + this->NoCMakePath = false; + this->NoCMakeEnvironmentPath = false; + this->NoSystemEnvironmentPath = false; + this->NoCMakeSystemPath = false; + + // OS X Bundle and Framework search policy. The default is to + // search frameworks first on apple. +#if defined(__APPLE__) + this->SearchFrameworkFirst = true; + this->SearchAppBundleFirst = true; +#else + this->SearchFrameworkFirst = false; + this->SearchAppBundleFirst = false; +#endif + this->SearchFrameworkOnly = false; + this->SearchFrameworkLast = false; + this->SearchAppBundleOnly = false; + this->SearchAppBundleLast = false; + + // Documentation components. + this->GenericDocumentationMacPolicy = + "On Darwin or systems supporting OS X Frameworks, the cmake variable" + " CMAKE_FIND_FRAMEWORK can be set to empty or one of the following:\n" + " \"FIRST\" - Try to find frameworks before standard\n" + " libraries or headers. This is the default on Darwin.\n" + " \"LAST\" - Try to find frameworks after standard\n" + " libraries or headers.\n" + " \"ONLY\" - Only try to find frameworks.\n" + " \"NEVER\". - Never try to find frameworks.\n" + "On Darwin or systems supporting OS X Application Bundles, the cmake " + "variable CMAKE_FIND_APPBUNDLE can be set to empty or one of the " + "following:\n" + " \"FIRST\" - Try to find application bundles before standard\n" + " programs. This is the default on Darwin.\n" + " \"LAST\" - Try to find application bundles after standard\n" + " programs.\n" + " \"ONLY\" - Only try to find application bundles.\n" + " \"NEVER\". - Never try to find application bundles.\n"; + this->GenericDocumentationRootPath = + "The CMake variable CMAKE_FIND_ROOT_PATH specifies one or more " + "directories to be prepended to all other search directories. " + "This effectively \"re-roots\" the entire search under given locations. " + "By default it is empty. It is especially useful when " + "cross-compiling to point to the root directory of the " + "target environment and CMake will search there too. By default at first " + "the directories listed in CMAKE_FIND_ROOT_PATH and then the non-rooted " + "directories will be searched. " + "The default behavior can be adjusted by setting " + "CMAKE_FIND_ROOT_PATH_MODE_XXX. This behavior can be manually " + "overridden on a per-call basis. " + "By using CMAKE_FIND_ROOT_PATH_BOTH the search order will " + "be as described above. If NO_CMAKE_FIND_ROOT_PATH is used " + "then CMAKE_FIND_ROOT_PATH will not be used. If ONLY_CMAKE_FIND_ROOT_PATH " + "is used then only the re-rooted directories will be searched.\n"; + this->GenericDocumentationPathsOrder = + "The reason the paths listed in the call to the command are searched " + "last is that most users of CMake would expect things to be found " + "first in the locations specified by their environment. Projects may " + "override this behavior by simply calling the command twice:\n" + " FIND_XXX(FIND_ARGS_XXX PATHS paths... NO_DEFAULT_PATH)\n" + " FIND_XXX(FIND_ARGS_XXX)\n" + "Once one of these calls succeeds the result variable will be set " + "and stored in the cache so that neither call will search again."; +} + +//---------------------------------------------------------------------------- +cmFindCommon::~cmFindCommon() +{ +} + +//---------------------------------------------------------------------------- +void cmFindCommon::SelectDefaultRootPathMode() +{ + // Use both by default. + this->FindRootPathMode = RootPathModeBoth; + + // Check the policy variable for this find command type. + std::string findRootPathVar = "CMAKE_FIND_ROOT_PATH_MODE_"; + findRootPathVar += this->CMakePathName; + std::string rootPathMode = + this->Makefile->GetSafeDefinition(findRootPathVar.c_str()); + if (rootPathMode=="NEVER") + { + this->FindRootPathMode = RootPathModeNoRootPath; + } + else if (rootPathMode=="ONLY") + { + this->FindRootPathMode = RootPathModeOnlyRootPath; + } + else if (rootPathMode=="BOTH") + { + this->FindRootPathMode = RootPathModeBoth; + } +} + +//---------------------------------------------------------------------------- +void cmFindCommon::SelectDefaultMacMode() +{ + std::string ff = this->Makefile->GetSafeDefinition("CMAKE_FIND_FRAMEWORK"); + if(ff == "NEVER") + { + this->SearchFrameworkLast = false; + this->SearchFrameworkFirst = false; + this->SearchFrameworkOnly = false; + } + else if(ff == "ONLY") + { + this->SearchFrameworkLast = false; + this->SearchFrameworkFirst = false; + this->SearchFrameworkOnly = true; + } + else if(ff == "FIRST") + { + this->SearchFrameworkLast = false; + this->SearchFrameworkFirst = true; + this->SearchFrameworkOnly = false; + } + else if(ff == "LAST") + { + this->SearchFrameworkLast = true; + this->SearchFrameworkFirst = false; + this->SearchFrameworkOnly = false; + } + + std::string fab = this->Makefile->GetSafeDefinition("CMAKE_FIND_APPBUNDLE"); + if(fab == "NEVER") + { + this->SearchAppBundleLast = false; + this->SearchAppBundleFirst = false; + this->SearchAppBundleOnly = false; + } + else if(fab == "ONLY") + { + this->SearchAppBundleLast = false; + this->SearchAppBundleFirst = false; + this->SearchAppBundleOnly = true; + } + else if(fab == "FIRST") + { + this->SearchAppBundleLast = false; + this->SearchAppBundleFirst = true; + this->SearchAppBundleOnly = false; + } + else if(fab == "LAST") + { + this->SearchAppBundleLast = true; + this->SearchAppBundleFirst = false; + this->SearchAppBundleOnly = false; + } +} + +//---------------------------------------------------------------------------- +void cmFindCommon::RerootPaths(std::vector<std::string>& paths) +{ +#if 0 + for(std::vector<std::string>::const_iterator i = paths.begin(); + i != paths.end(); ++i) + { + fprintf(stderr, "[%s]\n", i->c_str()); + } +#endif + + // Short-circuit if there is nothing to do. + if(this->FindRootPathMode == RootPathModeNoRootPath) + { + return; + } + const char* rootPath = + this->Makefile->GetDefinition("CMAKE_FIND_ROOT_PATH"); + if((rootPath == 0) || (strlen(rootPath) == 0)) + { + return; + } + + // Construct the list of path roots with no trailing slashes. + std::vector<std::string> roots; + cmSystemTools::ExpandListArgument(rootPath, roots); + for(std::vector<std::string>::iterator ri = roots.begin(); + ri != roots.end(); ++ri) + { + cmSystemTools::ConvertToUnixSlashes(*ri); + } + + // Copy the original set of unrooted paths. + std::vector<std::string> unrootedPaths = paths; + paths.clear(); + + for(std::vector<std::string>::const_iterator ri = roots.begin(); + ri != roots.end(); ++ri) + { + for(std::vector<std::string>::const_iterator ui = unrootedPaths.begin(); + ui != unrootedPaths.end(); ++ui) + { + // Place the unrooted path under the current root if it is not + // already inside. Skip the unrooted path if it is relative to + // a user home directory or is empty. + std::string rootedDir; + if(cmSystemTools::IsSubDirectory(ui->c_str(), ri->c_str())) + { + rootedDir = *ui; + } + else if(!ui->empty() && (*ui)[0] != '~') + { + // Start with the new root. + rootedDir = *ri; + rootedDir += "/"; + + // Append the original path with its old root removed. + rootedDir += cmSystemTools::SplitPathRootComponent(ui->c_str()); + } + + // Store the new path. + paths.push_back(rootedDir); + } + } + + // If searching both rooted and unrooted paths add the original + // paths again. + if(this->FindRootPathMode == RootPathModeBoth) + { + paths.insert(paths.end(), unrootedPaths.begin(), unrootedPaths.end()); + } +} + +//---------------------------------------------------------------------------- +bool cmFindCommon::CheckCommonArgument(std::string const& arg) +{ + if(arg == "NO_DEFAULT_PATH") + { + this->NoDefaultPath = true; + } + else if(arg == "NO_CMAKE_ENVIRONMENT_PATH") + { + this->NoCMakeEnvironmentPath = true; + } + else if(arg == "NO_CMAKE_PATH") + { + this->NoCMakePath = true; + } + else if(arg == "NO_SYSTEM_ENVIRONMENT_PATH") + { + this->NoSystemEnvironmentPath = true; + } + else if(arg == "NO_CMAKE_SYSTEM_PATH") + { + this->NoCMakeSystemPath = true; + } + else if(arg == "NO_CMAKE_FIND_ROOT_PATH") + { + this->FindRootPathMode = RootPathModeNoRootPath; + } + else if(arg == "ONLY_CMAKE_FIND_ROOT_PATH") + { + this->FindRootPathMode = RootPathModeOnlyRootPath; + } + else if(arg == "CMAKE_FIND_ROOT_PATH_BOTH") + { + this->FindRootPathMode = RootPathModeBoth; + } + else + { + // The argument is not one of the above. + return false; + } + + // The argument is one of the above. + return true; +} + +//---------------------------------------------------------------------------- +void cmFindCommon::AddPathSuffix(std::string const& arg) +{ + std::string suffix = arg; + + // Strip leading and trailing slashes. + if(suffix.empty()) + { + return; + } + if(suffix[0] == '/') + { + suffix = suffix.substr(1, suffix.npos); + } + if(suffix.empty()) + { + return; + } + if(suffix[suffix.size()-1] == '/') + { + suffix = suffix.substr(0, suffix.size()-1); + } + if(suffix.empty()) + { + return; + } + + // Store the suffix. + this->SearchPathSuffixes.push_back(suffix); +} + +//---------------------------------------------------------------------------- +void cmFindCommon::GetAppBundlePaths(std::vector<std::string>& paths) +{ + if(this->NoDefaultPath) + { + return; + } + std::vector<std::string> tmp; + + // first environment variables + if(!this->NoCMakeEnvironmentPath) + { + cmSystemTools::GetPath(tmp, "CMAKE_APPBUNDLE_PATH"); + this->AddPathsInternal(paths, tmp, EnvPath); + tmp.clear(); + } + + // add cmake variables + if(!this->NoCMakePath) + { + if(const char* path = + this->Makefile->GetDefinition("CMAKE_APPBUNDLE_PATH")) + { + cmSystemTools::ExpandListArgument(path, tmp); + this->AddPathsInternal(paths, tmp, CMakePath); + tmp.clear(); + } + } + + // add cmake system variables + if(!this->NoCMakeSystemPath) + { + if(const char* path = + this->Makefile->GetDefinition("CMAKE_SYSTEM_APPBUNDLE_PATH")) + { + cmSystemTools::ExpandListArgument(path, tmp); + this->AddPathsInternal(paths, tmp, CMakePath); + tmp.clear(); + } + } +} + +//---------------------------------------------------------------------------- +void cmFindCommon::GetFrameworkPaths(std::vector<std::string>& paths) +{ + if(this->NoDefaultPath) + { + return; + } + std::vector<std::string> tmp; + + // first environment variables + if(!this->NoCMakeEnvironmentPath) + { + cmSystemTools::GetPath(tmp, "CMAKE_FRAMEWORK_PATH"); + this->AddPathsInternal(paths, tmp, EnvPath); + tmp.clear(); + } + + // add cmake variables + if(!this->NoCMakePath) + { + if(const char* path = + this->Makefile->GetDefinition("CMAKE_FRAMEWORK_PATH")) + { + cmSystemTools::ExpandListArgument(path, tmp); + this->AddPathsInternal(paths, tmp, CMakePath); + tmp.clear(); + } + } + + // add cmake system variables + if(!this->NoCMakeSystemPath) + { + if(const char* path = + this->Makefile->GetDefinition("CMAKE_SYSTEM_FRAMEWORK_PATH")) + { + cmSystemTools::ExpandListArgument(path, tmp); + this->AddPathsInternal(paths, tmp, CMakePath); + tmp.clear(); + } + } +} + +//---------------------------------------------------------------------------- +void cmFindCommon::AddCMakePath(std::vector<std::string>& out_paths, + const char* variable, + std::set<cmStdString>* emmitted) +{ + // Get a path from a CMake variable. + if(const char* varPath = this->Makefile->GetDefinition(variable)) + { + std::vector<std::string> tmp; + cmSystemTools::ExpandListArgument(varPath, tmp); + + // Relative paths are interpreted with respect to the current + // source directory. + this->AddPathsInternal(out_paths, tmp, CMakePath, emmitted); + } +} + +//---------------------------------------------------------------------------- +void cmFindCommon::AddEnvPath(std::vector<std::string>& out_paths, + const char* variable, + std::set<cmStdString>* emmitted) +{ + // 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(out_paths, tmp, EnvPath, emmitted); +} + +//---------------------------------------------------------------------------- +void cmFindCommon::AddPathsInternal(std::vector<std::string>& out_paths, + std::vector<std::string> const& in_paths, + PathType pathType, + std::set<cmStdString>* emmitted) +{ + for(std::vector<std::string>::const_iterator i = in_paths.begin(); + i != in_paths.end(); ++i) + { + this->AddPathInternal(out_paths, *i, pathType, emmitted); + } +} + +//---------------------------------------------------------------------------- +void cmFindCommon::AddPathInternal(std::vector<std::string>& out_paths, + std::string const& in_path, + PathType pathType, + std::set<cmStdString>* emmitted) +{ + if(in_path.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.c_str(), relbase); + + // Insert the path if has not already been emmitted. + if(!emmitted || emmitted->insert(fullPath).second) + { + out_paths.push_back(fullPath.c_str()); + } +} diff --git a/Source/cmFindCommon.h b/Source/cmFindCommon.h new file mode 100644 index 0000000000..962a017bc0 --- /dev/null +++ b/Source/cmFindCommon.h @@ -0,0 +1,95 @@ +/*========================================================================= + + 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. + +=========================================================================*/ +#ifndef cmFindCommon_h +#define cmFindCommon_h + +#include "cmCommand.h" + +/** \class cmFindCommon + * \brief Base class for FIND_XXX implementations. + * + * cmFindCommon is a parent class for cmFindBase, + * cmFindProgramCommand, cmFindPathCommand, cmFindLibraryCommand, + * cmFindFileCommand, and cmFindPackageCommand. + */ +class cmFindCommon : public cmCommand +{ +public: + cmFindCommon(); + ~cmFindCommon(); + cmTypeMacro(cmFindCommon, cmCommand); + +protected: + + enum RootPathMode { RootPathModeBoth, + RootPathModeOnlyRootPath, + RootPathModeNoRootPath }; + + enum PathType { FullPath, CMakePath, EnvPath }; + + /** Place a set of search paths under the search roots. */ + void RerootPaths(std::vector<std::string>& paths); + + /** Compute the current default root path mode. */ + void SelectDefaultRootPathMode(); + + /** Compute the current default bundle/framework search policy. */ + void SelectDefaultMacMode(); + + cmStdString CMakePathName; + RootPathMode FindRootPathMode; + + bool CheckCommonArgument(std::string const& arg); + void AddPathSuffix(std::string const& arg); + void GetAppBundlePaths(std::vector<std::string>& paths); + void GetFrameworkPaths(std::vector<std::string>& paths); + + void AddCMakePath(std::vector<std::string>& out_paths, + const char* variable, std::set<cmStdString>* emmitted = 0); + void AddEnvPath(std::vector<std::string>& out_paths, + const char* variable, std::set<cmStdString>* emmitted = 0); + void AddPathsInternal(std::vector<std::string>& out_paths, + std::vector<std::string> const& in_paths, + PathType pathType, + std::set<cmStdString>* emmitted = 0); + void AddPathInternal(std::vector<std::string>& out_paths, + std::string const& in_path, + PathType pathType, + std::set<cmStdString>* emmitted = 0); + + bool NoDefaultPath; + bool NoCMakePath; + bool NoCMakeEnvironmentPath; + bool NoSystemEnvironmentPath; + bool NoCMakeSystemPath; + + std::vector<std::string> SearchPathSuffixes; + + std::string GenericDocumentationMacPolicy; + std::string GenericDocumentationRootPath; + std::string GenericDocumentationPathsOrder; + + bool SearchFrameworkFirst; + bool SearchFrameworkOnly; + bool SearchFrameworkLast; + + bool SearchAppBundleFirst; + bool SearchAppBundleOnly; + bool SearchAppBundleLast; +}; + +#endif diff --git a/Source/cmFindLibraryCommand.cxx b/Source/cmFindLibraryCommand.cxx index fb836c854b..bae60c4c1f 100644 --- a/Source/cmFindLibraryCommand.cxx +++ b/Source/cmFindLibraryCommand.cxx @@ -24,6 +24,12 @@ cmFindLibraryCommand::cmFindLibraryCommand() cmSystemTools::ReplaceString(this->GenericDocumentation, "CMAKE_XXX_PATH", "CMAKE_LIBRARY_PATH"); cmSystemTools::ReplaceString(this->GenericDocumentation, + "CMAKE_XXX_MAC_PATH", + "CMAKE_FRAMEWORK_PATH"); + cmSystemTools::ReplaceString(this->GenericDocumentation, + "CMAKE_SYSTEM_XXX_MAC_PATH", + "CMAKE_SYSTEM_FRAMEWORK_PATH"); + cmSystemTools::ReplaceString(this->GenericDocumentation, "XXX_SYSTEM", "LIB"); cmSystemTools::ReplaceString(this->GenericDocumentation, "CMAKE_SYSTEM_XXX_PATH", diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx index 96afe175ae..26b5197c24 100644 --- a/Source/cmFindPackageCommand.cxx +++ b/Source/cmFindPackageCommand.cxx @@ -48,6 +48,158 @@ void cmFindPackageNeedBackwardsCompatibility(const std::string& variable, } //---------------------------------------------------------------------------- +cmFindPackageCommand::cmFindPackageCommand() +{ + cmSystemTools::ReplaceString(this->GenericDocumentationRootPath, + "CMAKE_FIND_ROOT_PATH_MODE_XXX", + "CMAKE_FIND_ROOT_PATH_MODE_PACKAGE"); + cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder, + "FIND_ARGS_XXX", "<package>"); + cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder, + "FIND_XXX", "find_package"); + this->CMakePathName = "PACKAGE"; + this->Quiet = false; + this->Required = false; + this->NoBuilds = false; + this->NoModule = false; + this->DebugMode = false; + this->CommandDocumentation = + " find_package(<package> [major.minor] [QUIET] [NO_MODULE]\n" + " [[REQUIRED|COMPONENTS] [components...]]\n" + " [NAMES name1 [name2 ...]]\n" + " [CONFIGS config1 [config2 ...]]\n" + " [PATHS path1 [path2 ... ]]\n" + " [PATH_SUFFIXES suffix1 [suffix2 ...]]\n" + " [NO_DEFAULT_PATH]\n" + " [NO_CMAKE_ENVIRONMENT_PATH]\n" + " [NO_CMAKE_PATH]\n" + " [NO_SYSTEM_ENVIRONMENT_PATH]\n" + " [NO_CMAKE_BUILDS_PATH]\n" + " [NO_CMAKE_SYSTEM_PATH]\n" + " [CMAKE_FIND_ROOT_PATH_BOTH |\n" + " ONLY_CMAKE_FIND_ROOT_PATH |\n" + " NO_CMAKE_FIND_ROOT_PATH])\n" + "Finds and loads settings from an external project. <package>_FOUND " + "will be set to indicate whether the package was found. Settings that " + "can be used when <package>_FOUND is true are package-specific. " + "A package-specific list of components may be listed after the " + "REQUIRED option, or after the COMPONENTS option if no REQUIRED " + "option is given. The \"major.minor\" version argument is currently " + "a placeholder for future use and is ignored. " + "The command has two modes by which it searches for packages: " + "\"Module\" mode and \"Config\" mode." + "\n" + "Module mode has a reduced signature:\n" + " find_package(<package> [major.minor] [QUIET]\n" + " [[REQUIRED|COMPONENTS] [components...]])\n" + "CMake searches for a file called \"Find<package>.cmake\" in " + "the CMAKE_MODULE_PATH followed by the CMake installation. " + "If the file is found, it is read and processed by CMake. " + "It is responsible for finding the package " + "or producing an error message if package content cannot be found. " + "Otherwise the command proceeds to Config mode. The NO_MODULE " + "option may be used to skip Module mode explicitly, but the option " + "is implied by use of options not specified in the reduced signature." + "\n" + "Config mode attempts to locate a configuration file provided by the " + "package to be found. A cache entry called <package>_DIR is created to " + "hold the directory containing the file. " + "By default the command searches for a package with the name <package>. " + "If the NAMES option is given the names following it are used instead " + "of <package>. " + "The command searches for a file called \"<name>Config.cmake\" or " + "\"<lower-case-name>-config.cmake\" for each name specified. " + "A replacement set of possible configuration file names may be given " + "using the CONFIGS option. " + "The search procedure is specified below. Once found, the configuration " + "file is read and processed by CMake. Since the file is provided by the " + "package it already knows the location of package contents. " + "The full path to the configuration file is stored in the cmake " + "variable <package>_CONFIG." + "\n" + "If the package configuration file cannot be found CMake " + "will generate an error describing the problem unless the QUIET " + "argument is specified. If REQUIRED is specified and the package " + "is not found a fatal error is generated and the configure step stops " + "executing. If <package>_DIR has been set to a directory not containing " + "a configuration file a fatal error is always generated because user " + "intervention is required." + "\n" + "CMake constructs a set of possible installation prefixes for the " + "package. Under each prefix the following directories are searched " + "for a configuration file:\n" + " <prefix>/ (W)\n" + " <prefix>/(cmake|CMake)/ (W)\n" + " <prefix>/(share|lib)/<name>*/ (P)\n" + " <prefix>/(share|lib)/<name>*/(cmake|CMake)/ (P)\n" + "On systems supporting OS X Frameworks and Application Bundles " + "the following directories are searched for frameworks or bundles " + "containing a configuration file:\n" + " <prefix>/<name>.framework/Resources/ (A)\n" + " <prefix>/<name>.framework/Resources/CMake/ (A)\n" + " <prefix>/<name>.framework/Versions/*/Resources/ (A)\n" + " <prefix>/<name>.framework/Versions/*/Resources/CMake/ (A)\n" + " <prefix>/<name>.app/Contents/Resources/ (A)\n" + " <prefix>/<name>.app/Contents/Resources/CMake/ (A)\n" + "In all cases the <name> is treated as case-insensitive and corresponds " + "to any of the names specified (<package> or names given by NAMES). " + "If PATH_SUFFIXES is specified the suffixes are appended to each " + "(W) or (P) directory entry one-by-one.\n" + "This set of directories is intended to work in cooperation with " + "projects that provide configuration files in their installation trees. " + "Directories above marked with (W) are intended for installations on " + "Windows where the prefix may point at the top of an application's " + "installation directory. Those marked with (P) are intended for " + "installations on POSIX platforms where the prefix is shared by " + "multiple packages. This is merely a convention, so all (W) and (P) " + "directories are still searched on all platforms. " + "Directories marked with (A) are intended for installations on " + "Apple platforms. The cmake variables CMAKE_FIND_FRAMEWORK and " + "CMAKE_FIND_APPBUNDLE determine the order of preference " + "as specified below.\n" + "The set of installation prefixes is constructed using the following " + "steps. If NO_DEFAULT_PATH is specified steps 1-5 are skipped.\n" + "1. Search cmake specific environment variables. This " + "can be skipped if NO_CMAKE_ENVIRONMENT_PATH is passed.\n" + " CMAKE_PREFIX_PATH\n" + " CMAKE_FRAMEWORK_PATH\n" + " CMAKE_APPBUNDLE_PATH\n" + "2. Search cmake variables with the same names as the cmake specific " + "environment variables. These are intended to be used on the command " + "line with a -DVAR=value. This can be skipped if NO_CMAKE_PATH " + "is passed.\n" + " CMAKE_PREFIX_PATH\n" + " CMAKE_FRAMEWORK_PATH\n" + " CMAKE_APPBUNDLE_PATH\n" + "3. Search the standard system environment variables. " + "This can be skipped if NO_SYSTEM_ENVIRONMENT_PATH is passed. " + "Path entries ending in \"/bin\" or \"/sbin\" are automatically " + "converted to their parent directories.\n" + " PATH\n" + "4. Search project build trees recently configured in a CMake GUI. " + "This can be skipped if NO_CMAKE_BUILDS_PATH is passed. " + "It is intended for the case when a user is building multiple " + "dependent projects one after another.\n" + "5. Search cmake variables defined in the Platform files " + "for the current system. This can be skipped if NO_CMAKE_SYSTEM_PATH " + "is passed.\n" + " CMAKE_SYSTEM_PREFIX_PATH\n" + " CMAKE_SYSTEM_FRAMEWORK_PATH\n" + " CMAKE_SYSTEM_APPBUNDLE_PATH\n" + "6. Search paths specified by the PATHS option.\n" + ; + this->CommandDocumentation += this->GenericDocumentationMacPolicy; + this->CommandDocumentation += this->GenericDocumentationRootPath; + this->CommandDocumentation += this->GenericDocumentationPathsOrder; +} + +//---------------------------------------------------------------------------- +const char* cmFindPackageCommand::GetFullDocumentation() +{ + return this->CommandDocumentation.c_str(); +} + +//---------------------------------------------------------------------------- bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args) { if(args.size() < 1) @@ -56,40 +208,94 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args) return false; } + // Check for debug mode. + this->DebugMode = this->Makefile->IsOn("CMAKE_FIND_DEBUG_MODE"); + + // Find the current root path mode. + this->SelectDefaultRootPathMode(); + + // Find the current bundle/framework search policy. + this->SelectDefaultMacMode(); + // Record options. this->Name = args[0]; - bool quiet = false; - bool required = false; - bool no_module = false; std::string components; const char* components_sep = ""; + // Check ancient compatibility. + this->Compatibility_1_6 = + this->Makefile->GetLocalGenerator() + ->NeedBackwardsCompatibility(1, 6); + + // Always search directly in a generated path. + this->SearchPathSuffixes.push_back(""); + // Parse the arguments. - bool doing_components = false; + enum Doing { DoingNone, DoingComponents, DoingNames, DoingPaths, + DoingPathSuffixes, DoingConfigs }; + Doing doing = DoingNone; cmsys::RegularExpression version("^[0-9.]+$"); bool haveVersion = false; for(unsigned int i=1; i < args.size(); ++i) { if(args[i] == "QUIET") { - quiet = true; - doing_components = false; + this->Quiet = true; + doing = DoingNone; } else if(args[i] == "NO_MODULE") { - no_module = true; - doing_components = false; + this->NoModule = true; + doing = DoingNone; } else if(args[i] == "REQUIRED") { - required = true; - doing_components = true; + this->Required = true; + doing = DoingComponents; } else if(args[i] == "COMPONENTS") { - doing_components = true; + this->Compatibility_1_6 = false; + doing = DoingComponents; + } + else if(args[i] == "NAMES") + { + this->NoModule = true; + this->Compatibility_1_6 = false; + doing = DoingNames; } - else if(doing_components) + else if(args[i] == "PATHS") + { + this->NoModule = true; + this->Compatibility_1_6 = false; + doing = DoingPaths; + } + else if(args[i] == "PATH_SUFFIXES") + { + this->NoModule = true; + this->Compatibility_1_6 = false; + doing = DoingPathSuffixes; + } + else if(args[i] == "CONFIGS") + { + this->NoModule = true; + this->Compatibility_1_6 = false; + doing = DoingConfigs; + } + else if(args[i] == "NO_CMAKE_BUILDS_PATH") + { + this->NoBuilds = true; + this->NoModule = true; + this->Compatibility_1_6 = false; + doing = DoingNone; + } + else if(this->CheckCommonArgument(args[i])) + { + this->NoModule = true; + this->Compatibility_1_6 = false; + doing = DoingNone; + } + else if(doing == DoingComponents) { // Set a variable telling the find script this component // is required. @@ -101,6 +307,22 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args) components += args[i]; components_sep = ";"; } + else if(doing == DoingNames) + { + this->Names.push_back(args[i]); + } + else if(doing == DoingPaths) + { + this->AddUserPath(args[i]); + } + else if(doing == DoingPathSuffixes) + { + this->AddPathSuffix(args[i]); + } + else if(doing == DoingConfigs) + { + this->Configs.push_back(args[i]); + } else if(!haveVersion && version.find(args[i].c_str())) { haveVersion = true; @@ -118,48 +340,105 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args) std::string components_var = Name + "_FIND_COMPONENTS"; this->Makefile->AddDefinition(components_var.c_str(), components.c_str()); - // See if there is a Find<name>.cmake module. - if(!no_module) + // See if there is a Find<package>.cmake module. + if(!this->NoModule) { bool foundModule = false; - if(!this->FindModule(foundModule, quiet, required)) + if(!this->FindModule(foundModule)) { - this->AppendSuccessInformation(quiet); + this->AppendSuccessInformation(); return false; } if(foundModule) { - this->AppendSuccessInformation(quiet); + this->AppendSuccessInformation(); return true; } } // No find module. Assume the project has a CMake config file. Use - // a <NAME>_DIR cache variable to locate it. + // a <package>_DIR cache variable to locate it. this->Variable = this->Name; this->Variable += "_DIR"; - this->Config = this->Name; - this->Config += "Config.cmake"; + // Add the default name. + if(this->Names.empty()) + { + this->Names.push_back(this->Name); + } + + // Add the default configs. + if(this->Configs.empty()) + { + for(std::vector<std::string>::const_iterator ni = this->Names.begin(); + ni != this->Names.end(); ++ni) + { + std::string config = *ni; + config += "Config.cmake"; + this->Configs.push_back(config); + + config = cmSystemTools::LowerCase(*ni); + config += "-config.cmake"; + this->Configs.push_back(config); + } + } + + // Find and load the package. + bool result = this->HandlePackageMode(); + this->AppendSuccessInformation(); + return result; +} + +//---------------------------------------------------------------------------- +bool cmFindPackageCommand::FindModule(bool& found) +{ + std::string module = "Find"; + module += this->Name; + module += ".cmake"; + std::string mfile = this->Makefile->GetModulesFile(module.c_str()); + if ( mfile.size() ) + { + if(this->Quiet) + { + // Tell the module that is about to be read that it should find + // quietly. + std::string quietly = this->Name; + quietly += "_FIND_QUIETLY"; + this->Makefile->AddDefinition(quietly.c_str(), "1"); + } + + if(this->Required) + { + // Tell the module that is about to be read that it should report + // a fatal error if the package is not found. + std::string req = this->Name; + req += "_FIND_REQUIRED"; + this->Makefile->AddDefinition(req.c_str(), "1"); + } + + // Load the module we found. + found = true; + return this->ReadListFile(mfile.c_str()); + } + return true; +} + +//---------------------------------------------------------------------------- +bool cmFindPackageCommand::HandlePackageMode() +{ // Support old capitalization behavior. std::string upperDir = cmSystemTools::UpperCase(this->Name); std::string upperFound = cmSystemTools::UpperCase(this->Name); upperDir += "_DIR"; upperFound += "_FOUND"; - bool needCompatibility = false; - if(!(upperDir == this->Variable)) + if(upperDir == this->Variable) { - const char* versionValue = - this->Makefile->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY"); - if(atof(versionValue) < 1.7) - { - needCompatibility = true; - } + this->Compatibility_1_6 = false; } // Try to find the config file. const char* def = this->Makefile->GetDefinition(this->Variable.c_str()); - if(needCompatibility && cmSystemTools::IsOff(def)) + if(this->Compatibility_1_6 && cmSystemTools::IsOff(def)) { // Use the setting of the old name of the variable to provide the // value of the new. @@ -170,70 +449,104 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args) def = this->Makefile->GetDefinition(this->Variable.c_str()); } } + + // Search for the config file if it is not already found. if(cmSystemTools::IsOff(def)) { - if(!this->FindConfig()) - { - this->AppendSuccessInformation(quiet); - return false; - } + this->FindConfig(); + def = this->Makefile->GetDefinition(this->Variable.c_str()); } // If the config file was found, load it. + std::string file; bool result = true; bool found = false; - def = this->Makefile->GetDefinition(this->Variable.c_str()); if(!cmSystemTools::IsOff(def)) { - std::string f = def; - cmSystemTools::ConvertToUnixSlashes(f); - f += "/"; - f += this->Config; - if(!cmSystemTools::FileIsFullPath(f.c_str())) + // Get the directory from the variable value. + std::string dir = def; + cmSystemTools::ConvertToUnixSlashes(dir); + + // Treat relative paths with respect to the current source dir. + if(!cmSystemTools::FileIsFullPath(dir.c_str())) { - f = "/" + f; - f = this->Makefile->GetCurrentDirectory() + f; + dir = "/" + dir; + dir = this->Makefile->GetCurrentDirectory() + dir; } - if(cmSystemTools::FileExists(f.c_str())) + // Find the configuration file. + if(this->FindConfigFile(dir, file)) { - if(this->ReadListFile(f.c_str())) + // Parse the configuration file. + if(this->ReadListFile(file.c_str())) { + // The package has been found. found = true; } else { + // The configuration file is invalid. result = false; } } else { + // The variable setting is wrong. cmOStringStream e; - e << this->Variable << " is set to \"" << def << "\", which is " - << "not a directory containing " << this->Config; - cmSystemTools::Error(e.str().c_str()); - if(required) - { - cmSystemTools::SetFatalErrorOccured(); - } - result = true; + e << "cannot find package " << this->Name << " because " + << this->Variable << " is set to \"" << def << "\" " + << "which is not a directory containing a package configuration " + << "file. " + << "Please set the cache entry " << this->Variable << " " + << "to the correct directory, or delete it to ask CMake " + << "to search."; + this->SetError(e.str().c_str()); + result = false; } } - else if(!quiet || required) + else if(!this->Quiet || this->Required) { + // The variable is not set. cmOStringStream e; - e << "FIND_PACKAGE could not find Find" << this->Name - << ".cmake nor config file " << this->Config << ".\n" - << "Adjust CMAKE_MODULE_PATH to find Find" << this->Name - << ".cmake or set " << this->Variable - << "\nto the directory containing " << this->Config - << " in order to use " << this->Name << "."; - cmSystemTools::Error(e.str().c_str()); - if(required) + e << "could not find "; + if(!this->NoModule) + { + e << "module Find" << this->Name << ".cmake or "; + } + e << "a configuration file for package " << this->Name << ".\n"; + if(!this->NoModule) + { + e << "Adjust CMAKE_MODULE_PATH to find Find" + << this->Name << ".cmake or set "; + } + else + { + e << "Set "; + } + e << this->Variable << " to the directory containing a CMake " + << "configuration file for " << this->Name << ". "; + if(this->Configs.size() == 1) + { + e << "The file will be called " << this->Configs[0]; + } + else + { + e << "The file will have one of the following names:\n"; + for(std::vector<std::string>::const_iterator ci = this->Configs.begin(); + ci != this->Configs.end(); ++ci) + { + e << " " << *ci << "\n"; + } + } + if(this->Required) + { + this->SetError(e.str().c_str()); + result = false; + } + else { - cmSystemTools::SetFatalErrorOccured(); + cmSystemTools::Error("find_package ", e.str().c_str()); } - result = true; } // Set a variable marking whether the package was found. @@ -241,7 +554,20 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args) foundVar += "_FOUND"; this->Makefile->AddDefinition(foundVar.c_str(), found? "1":"0"); - if(needCompatibility) + // Set a variable naming the configuration file that was found. + std::string fileVar = this->Name; + fileVar += "_CONFIG"; + if(found) + { + this->Makefile->AddDefinition(fileVar.c_str(), file.c_str()); + } + else + { + this->Makefile->RemoveDefinition(fileVar.c_str()); + } + + // Handle some ancient compatibility stuff. + if(this->Compatibility_1_6) { // Listfiles will be looking for the capitalized version of the // name. Provide it. @@ -256,7 +582,7 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args) #ifdef CMAKE_BUILD_WITH_CMAKE if(!(upperDir == this->Variable)) { - if(needCompatibility) + if(this->Compatibility_1_6) { // Listfiles may use the capitalized version of the name. // Remove any previously added watch. @@ -277,155 +603,107 @@ bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args) } #endif - this->AppendSuccessInformation(quiet); return result; } //---------------------------------------------------------------------------- -bool cmFindPackageCommand::FindModule(bool& found, bool quiet, bool required) +void cmFindPackageCommand::FindConfig() { - std::string module = "Find"; - module += this->Name; - module += ".cmake"; - std::string mfile = this->Makefile->GetModulesFile(module.c_str()); - if ( mfile.size() ) - { - if(quiet) - { - // Tell the module that is about to be read that it should find - // quietly. - std::string quietly = this->Name; - quietly += "_FIND_QUIETLY"; - this->Makefile->AddDefinition(quietly.c_str(), "1"); - } + // Compute the set of search prefixes. + this->ComputePrefixes(); - if(required) - { - // Tell the module that is about to be read that it should report - // a fatal error if the package is not found. - std::string req = this->Name; - req += "_FIND_REQUIRED"; - this->Makefile->AddDefinition(req.c_str(), "1"); - } + // Look for the project's configuration file. + bool found = false; - // Load the module we found. - found = true; - return this->ReadListFile(mfile.c_str()); + // Search for frameworks. + if(!found && this->SearchFrameworkFirst || this->SearchFrameworkOnly) + { + found = this->FindFrameworkConfig(); } - return true; -} -//---------------------------------------------------------------------------- -bool cmFindPackageCommand::FindConfig() -{ - std::string help = "The directory containing "; - help += this->Config; - help += "."; - - // Construct the list of relative paths to each prefix to be - // searched. - std::string rel = "/lib/"; - rel += cmSystemTools::LowerCase(this->Name); - this->Relatives.push_back(rel); - rel = "/lib/"; - rel += this->Name; - this->Relatives.push_back(rel); + // Search for apps. + if(!found && this->SearchAppBundleFirst || this->SearchAppBundleOnly) + { + found = this->FindAppBundleConfig(); + } - // It is likely that CMake will have recently built the project. - for(int i=1; i <= 10; ++i) + // Search prefixes. + if(!found && !(this->SearchFrameworkOnly || this->SearchAppBundleOnly)) { - cmOStringStream r; - r << "[HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\" - "Settings\\StartPath;WhereBuild" << i << "]"; - std::string entry = r.str(); - cmSystemTools::ExpandRegistryValues(entry); - cmSystemTools::ConvertToUnixSlashes(entry); - if(cmSystemTools::FileIsDirectory(entry.c_str())) - { - this->Builds.push_back(entry); - } + found = this->FindPrefixedConfig(); } - // The project may be installed. Use the system search path to - // construct a list of possible install prefixes. - std::vector<std::string> systemPath; - cmSystemTools::GetPath(systemPath); - for(std::vector<std::string>::iterator i = systemPath.begin(); - i != systemPath.end(); ++i) + // Search for frameworks. + if(!found && this->SearchFrameworkLast) { - *i += "/.."; - if(cmSystemTools::FileIsDirectory(i->c_str())) - { - this->Prefixes.push_back(cmSystemTools::CollapseFullPath(i->c_str())); - } + found = this->FindFrameworkConfig(); } -#if !defined(WIN32) || defined(__CYGWIN__) - this->Prefixes.push_back("/usr/local"); - this->Prefixes.push_back("/usr"); -#endif - // Look for the project's configuration file. - std::string init = this->SearchForConfig(); + // Search for apps. + if(!found && this->SearchAppBundleLast) + { + found = this->FindAppBundleConfig(); + } // Store the entry in the cache so it can be set by the user. + std::string init; + if(found) + { + init = cmSystemTools::GetFilenamePath(this->FileFound); + } + else + { + init = this->Variable + "-NOTFOUND"; + } + std::string help = + "The directory containing a CMake configuration file for "; + help += this->Name; + help += "."; this->Makefile->AddCacheDefinition(this->Variable.c_str(), - init.c_str(), - help.c_str(), - cmCacheManager::PATH); - return true; + init.c_str(), help.c_str(), + cmCacheManager::PATH); } //---------------------------------------------------------------------------- -std::string cmFindPackageCommand::SearchForConfig() const +bool cmFindPackageCommand::FindPrefixedConfig() { - // Check the environment variable. - std::string env; - if(cmSystemTools::GetEnv(this->Variable.c_str(), env) && env.length() > 0) + for(std::vector<std::string>::const_iterator pi = this->Prefixes.begin(); + pi != this->Prefixes.end(); ++pi) { - cmSystemTools::ConvertToUnixSlashes(env); - std::string f = env; - f += "/"; - f += this->Config; - if(cmSystemTools::FileExists(f.c_str())) + if(this->SearchPrefix(*pi)) { - return env; + return true; } } + return false; +} - // Search the build directories. - for(std::vector<cmStdString>::const_iterator b = this->Builds.begin(); - b != this->Builds.end(); ++b) +//---------------------------------------------------------------------------- +bool cmFindPackageCommand::FindFrameworkConfig() +{ + for(std::vector<std::string>::const_iterator i = this->Prefixes.begin(); + i != this->Prefixes.end(); ++i) { - std::string f = *b; - f += "/"; - f += this->Config; - if(cmSystemTools::FileExists(f.c_str())) + if(this->SearchFrameworkPrefix(*i)) { - return *b; + return true; } } + return false; +} - // Search paths relative to each installation prefix. - for(std::vector<cmStdString>::const_iterator p = this->Prefixes.begin(); - p != this->Prefixes.end(); ++p) +//---------------------------------------------------------------------------- +bool cmFindPackageCommand::FindAppBundleConfig() +{ + for(std::vector<std::string>::const_iterator i = this->Prefixes.begin(); + i != this->Prefixes.end(); ++i) { - std::string prefix = *p; - for(std::vector<cmStdString>::const_iterator r = this->Relatives.begin(); - r != this->Relatives.end(); ++r) + if(this->SearchAppBundlePrefix(*i)) { - std::string dir = prefix; - dir += *r; - std::string f = dir; - f += "/"; - f += this->Config; - if(cmSystemTools::FileExists(f.c_str())) - { - return dir; - } + return true; } } - - return this->Variable + "-NOTFOUND"; + return false; } //---------------------------------------------------------------------------- @@ -480,7 +758,7 @@ void cmFindPackageCommand::AppendToProperty(const char* propertyName) } //---------------------------------------------------------------------------- -void cmFindPackageCommand::AppendSuccessInformation(bool quiet) +void cmFindPackageCommand::AppendSuccessInformation() { std::string found = this->Name; found += "_FOUND"; @@ -491,7 +769,7 @@ void cmFindPackageCommand::AppendSuccessInformation(bool quiet) if ((cmSystemTools::IsOn(result)) || (cmSystemTools::IsOn(upperResult))) { this->AppendToProperty("PACKAGES_FOUND"); - if (!quiet) + if (!this->Quiet) { this->AppendToProperty("ENABLED_FEATURES"); } @@ -499,9 +777,725 @@ void cmFindPackageCommand::AppendSuccessInformation(bool quiet) else { this->AppendToProperty("PACKAGES_NOT_FOUND"); - if (!quiet) + if (!this->Quiet) { this->AppendToProperty("DISABLED_FEATURES"); } } } + +//---------------------------------------------------------------------------- +void cmFindPackageCommand::AddUserPath(std::string const& p) +{ + std::string userPath = p; + cmSystemTools::ExpandRegistryValues(userPath); + this->UserPaths.push_back(userPath); +} + +//---------------------------------------------------------------------------- +void cmFindPackageCommand::ComputePrefixes() +{ + std::vector<std::string>& prefixes = this->Prefixes; + std::set<cmStdString> emmitted; + + 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) + { + cmSystemTools::ConvertToUnixSlashes(env); + this->AddPathInternal(prefixes, env, EnvPath, &emmitted); + } + + this->AddEnvPath(prefixes, "CMAKE_PREFIX_PATH", &emmitted); + this->AddEnvPath(prefixes, "CMAKE_FRAMEWORK_PATH", &emmitted); + this->AddEnvPath(prefixes, "CMAKE_APPBUNDLE_PATH", &emmitted); + } + + if(!this->NoCMakePath && !this->NoDefaultPath) + { + this->AddCMakePath(prefixes, "CMAKE_PREFIX_PATH", &emmitted); + this->AddCMakePath(prefixes, "CMAKE_FRAMEWORK_PATH", &emmitted); + this->AddCMakePath(prefixes, "CMAKE_APPBUNDLE_PATH", &emmitted); + } + + 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) + { + std::string const& d = *i; + + // If the path is a PREFIX/bin case then add its parent instead. + if(d.size() >= 4 && strcmp(d.c_str()+d.size()-4, "/bin") == 0 || + d.size() >= 5 && strcmp(d.c_str()+d.size()-5, "/sbin") == 0) + { + this->AddPathInternal(prefixes, + cmSystemTools::GetFilenamePath(d), + EnvPath, &emmitted); + } + else + { + this->AddPathInternal(prefixes, d, EnvPath, &emmitted); + } + } + } + + if(!this->NoBuilds && !this->NoDefaultPath) + { + // It is likely that CMake will have recently built the project. + for(int i=1; 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(prefixes, f, FullPath, &emmitted); + } + } + } + + if(!this->NoCMakeSystemPath && !this->NoDefaultPath) + { + this->AddCMakePath(prefixes, "CMAKE_SYSTEM_PREFIX_PATH", &emmitted); + this->AddCMakePath(prefixes, "CMAKE_SYSTEM_FRAMEWORK_PATH", &emmitted); + this->AddCMakePath(prefixes, "CMAKE_SYSTEM_APPBUNDLE_PATH", &emmitted); + } + + if(!this->UserPaths.empty()) + { + // Add paths specified by the caller. + this->AddPathsInternal(prefixes, this->UserPaths, CMakePath, &emmitted); + } + + // Construct the final set of prefixes. + this->RerootPaths(prefixes); + + // Add a trailing slash to all prefixes to aid the search process. + for(std::vector<std::string>::iterator i = prefixes.begin(); + i != prefixes.end(); ++i) + { + std::string& prefix = *i; + if(prefix[prefix.size()-1] != '/') + { + prefix += "/"; + } + } +} + +//---------------------------------------------------------------------------- +bool cmFindPackageCommand::SearchDirectory(std::string const& dir) +{ + assert(!dir.empty() && dir[dir.size()-1] == '/'); + + // Check each path suffix on this directory. + for(std::vector<std::string>::const_iterator + si = this->SearchPathSuffixes.begin(); + si != this->SearchPathSuffixes.end(); ++si) + { + std::string d = dir; + if(!si->empty()) + { + d += *si; + d += "/"; + } + if(this->CheckDirectory(d)) + { + return true; + } + } + return false; +} + +//---------------------------------------------------------------------------- +bool cmFindPackageCommand::CheckDirectory(std::string const& dir) +{ + assert(!dir.empty() && dir[dir.size()-1] == '/'); + + // Look for the file in this directory. + std::string d = dir.substr(0, dir.size()-1); + if(this->FindConfigFile(d, this->FileFound)) + { + return true; + } + return false; +} + +//---------------------------------------------------------------------------- +bool cmFindPackageCommand::FindConfigFile(std::string const& dir, + std::string& file) +{ + for(std::vector<std::string>::const_iterator ci = this->Configs.begin(); + ci != this->Configs.end(); ++ci) + { + file = dir; + file += "/"; + file += *ci; + if(this->DebugMode) + { + fprintf(stderr, "Checking file [%s]\n", file.c_str()); + } + if(cmSystemTools::FileExists(file.c_str(), true)) + { + return true; + } + } + return false; +} + +//---------------------------------------------------------------------------- +#include <cmsys/Directory.hxx> +#include <cmsys/Glob.hxx> +#include <cmsys/String.h> +#include <cmsys/auto_ptr.hxx> + +class cmFileList; +class cmFileListGeneratorBase +{ +protected: + bool Consider(std::string const& fullPath, cmFileList& listing); +private: + bool Search(cmFileList&); + virtual bool Search(std::string const& parent, cmFileList&) = 0; + virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const = 0; + friend class cmFileList; + cmFileListGeneratorBase* SetNext(cmFileListGeneratorBase const& next); + cmsys::auto_ptr<cmFileListGeneratorBase> Next; +}; + +class cmFileList +{ +public: + cmFileList(): First(), Last(0) {} + cmFileList& operator/(cmFileListGeneratorBase const& rhs) + { + if(this->Last) + { + this->Last = this->Last->SetNext(rhs); + } + else + { + this->First = rhs.Clone(); + this->Last = this->First.get(); + } + return *this; + } + bool Search() + { + if(this->First.get()) + { + return this->First->Search(*this); + } + return false; + } +private: + virtual bool Visit(std::string const& fullPath) = 0; + friend class cmFileListGeneratorBase; + cmsys::auto_ptr<cmFileListGeneratorBase> First; + cmFileListGeneratorBase* Last; +}; + +class cmFindPackageFileList: public cmFileList +{ +public: + cmFindPackageFileList(cmFindPackageCommand* fpc, + bool use_suffixes = true): + cmFileList(), FPC(fpc), UseSuffixes(use_suffixes) {} +private: + bool Visit(std::string const& fullPath) + { + if(this->UseSuffixes) + { + return this->FPC->SearchDirectory(fullPath); + } + else + { + return this->FPC->CheckDirectory(fullPath); + } + } + cmFindPackageCommand* FPC; + bool UseSuffixes; +}; + +bool cmFileListGeneratorBase::Search(cmFileList& listing) +{ + return this->Search("", listing); +} + +cmFileListGeneratorBase* +cmFileListGeneratorBase::SetNext(cmFileListGeneratorBase const& next) +{ + this->Next = next.Clone(); + return this->Next.get(); +} + +bool cmFileListGeneratorBase::Consider(std::string const& fullPath, + cmFileList& listing) +{ + if(this->Next.get()) + { + return this->Next->Search(fullPath + "/", listing); + } + else + { + return listing.Visit(fullPath + "/"); + } +} + +class cmFileListGeneratorFixed: public cmFileListGeneratorBase +{ +public: + cmFileListGeneratorFixed(std::string const& str): + cmFileListGeneratorBase(), String(str) {} + cmFileListGeneratorFixed(cmFileListGeneratorFixed const& r): + cmFileListGeneratorBase(), String(r.String) {} +private: + std::string String; + virtual bool Search(std::string const& parent, cmFileList& lister) + { + std::string fullPath = parent + this->String; + return this->Consider(fullPath, lister); + } + virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const + { + cmsys::auto_ptr<cmFileListGeneratorBase> + g(new cmFileListGeneratorFixed(*this)); + return g; + } +}; + +class cmFileListGeneratorEnumerate: public cmFileListGeneratorBase +{ +public: + cmFileListGeneratorEnumerate(const char* p1, const char* p2): + cmFileListGeneratorBase() + { + this->Vector.push_back(p1); + this->Vector.push_back(p2); + } + cmFileListGeneratorEnumerate(cmFileListGeneratorEnumerate const& r): + cmFileListGeneratorBase(), Vector(r.Vector) {} +private: + std::vector<std::string> Vector; + virtual bool Search(std::string const& parent, cmFileList& lister) + { + for(std::vector<std::string>::const_iterator i = this->Vector.begin(); + i != this->Vector.end(); ++i) + { + if(this->Consider(parent + *i, lister)) + { + return true; + } + } + return false; + } + virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const + { + cmsys::auto_ptr<cmFileListGeneratorBase> + g(new cmFileListGeneratorEnumerate(*this)); + return g; + } +}; + +class cmFileListGeneratorProject: public cmFileListGeneratorBase +{ +public: + cmFileListGeneratorProject(std::vector<std::string> const& names): + cmFileListGeneratorBase(), Names(names) {} + cmFileListGeneratorProject(cmFileListGeneratorProject const& r): + cmFileListGeneratorBase(), Names(r.Names) {} +private: + std::vector<std::string> const& Names; + virtual bool Search(std::string const& parent, cmFileList& lister) + { + // Construct a list of matches. + std::vector<std::string> matches; + cmsys::Directory d; + d.Load(parent.c_str()); + for(unsigned long i=0; i < d.GetNumberOfFiles(); ++i) + { + const char* fname = d.GetFile(i); + if(strcmp(fname, ".") == 0 || + strcmp(fname, "..") == 0) + { + continue; + } + for(std::vector<std::string>::const_iterator ni = this->Names.begin(); + ni != this->Names.end(); ++ni) + { + if(cmsysString_strncasecmp(fname, ni->c_str(), + ni->length()) == 0) + { + matches.push_back(fname); + } + } + } + + for(std::vector<std::string>::const_iterator i = matches.begin(); + i != matches.end(); ++i) + { + if(this->Consider(parent + *i, lister)) + { + return true; + } + } + return false; + } + virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const + { + cmsys::auto_ptr<cmFileListGeneratorBase> + g(new cmFileListGeneratorProject(*this)); + return g; + } +}; + +class cmFileListGeneratorMacProject: public cmFileListGeneratorBase +{ +public: + cmFileListGeneratorMacProject(std::vector<std::string> const& names, + const char* ext): + cmFileListGeneratorBase(), Names(names), Extension(ext) {} + cmFileListGeneratorMacProject(cmFileListGeneratorMacProject const& r): + cmFileListGeneratorBase(), Names(r.Names), Extension(r.Extension) {} +private: + std::vector<std::string> const& Names; + std::string Extension; + virtual bool Search(std::string const& parent, cmFileList& lister) + { + // Construct a list of matches. + std::vector<std::string> matches; + cmsys::Directory d; + d.Load(parent.c_str()); + for(unsigned long i=0; i < d.GetNumberOfFiles(); ++i) + { + const char* fname = d.GetFile(i); + if(strcmp(fname, ".") == 0 || + strcmp(fname, "..") == 0) + { + continue; + } + for(std::vector<std::string>::const_iterator ni = this->Names.begin(); + ni != this->Names.end(); ++ni) + { + std::string name = *ni; + name += this->Extension; + if(cmsysString_strcasecmp(fname, name.c_str()) == 0) + { + matches.push_back(fname); + } + } + } + + for(std::vector<std::string>::const_iterator i = matches.begin(); + i != matches.end(); ++i) + { + if(this->Consider(parent + *i, lister)) + { + return true; + } + } + return false; + } + virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const + { + cmsys::auto_ptr<cmFileListGeneratorBase> + g(new cmFileListGeneratorMacProject(*this)); + return g; + } +}; + +class cmFileListGeneratorCaseInsensitive: public cmFileListGeneratorBase +{ +public: + cmFileListGeneratorCaseInsensitive(std::string const& str): + cmFileListGeneratorBase(), String(str) {} + cmFileListGeneratorCaseInsensitive(cmFileListGeneratorCaseInsensitive const& r): + cmFileListGeneratorBase(), String(r.String) {} +private: + std::string String; + virtual bool Search(std::string const& parent, cmFileList& lister) + { + // Look for matching files. + std::vector<std::string> matches; + cmsys::Directory d; + d.Load(parent.c_str()); + for(unsigned long i=0; i < d.GetNumberOfFiles(); ++i) + { + const char* fname = d.GetFile(i); + if(strcmp(fname, ".") == 0 || + strcmp(fname, "..") == 0) + { + continue; + } + if(cmsysString_strcasecmp(fname, this->String.c_str()) == 0) + { + if(this->Consider(parent + fname, lister)) + { + return true; + } + } + } + return false; + } + virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const + { + cmsys::auto_ptr<cmFileListGeneratorBase> + g(new cmFileListGeneratorCaseInsensitive(*this)); + return g; + } +}; + +class cmFileListGeneratorGlob: public cmFileListGeneratorBase +{ +public: + cmFileListGeneratorGlob(std::string const& str): + cmFileListGeneratorBase(), Pattern(str) {} + cmFileListGeneratorGlob(cmFileListGeneratorGlob const& r): + cmFileListGeneratorBase(), Pattern(r.Pattern) {} +private: + std::string Pattern; + virtual bool Search(std::string const& parent, cmFileList& lister) + { + // Glob the set of matching files. + std::string expr = parent; + expr += this->Pattern; + cmsys::Glob g; + if(!g.FindFiles(expr)) + { + return false; + } + std::vector<std::string> const& files = g.GetFiles(); + + // Look for directories among the matches. + for(std::vector<std::string>::const_iterator fi = files.begin(); + fi != files.end(); ++fi) + { + if(cmSystemTools::FileIsDirectory(fi->c_str())) + { + if(this->Consider(*fi, lister)) + { + return true; + } + } + } + return false; + } + virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const + { + cmsys::auto_ptr<cmFileListGeneratorBase> + g(new cmFileListGeneratorGlob(*this)); + return g; + } +}; + +//---------------------------------------------------------------------------- +bool cmFindPackageCommand::SearchPrefix(std::string const& prefix_in) +{ + assert(!prefix_in.empty() && prefix_in[prefix_in.size()-1] == '/'); + if(this->DebugMode) + { + fprintf(stderr, "Checking prefix [%s]\n", prefix_in.c_str()); + } + + // Skip this if the prefix does not exist. + if(!cmSystemTools::FileIsDirectory(prefix_in.c_str())) + { + return false; + } + + // PREFIX/ (useful on windows or in build trees) + if(this->SearchDirectory(prefix_in)) + { + return true; + } + + // Strip the trailing slash because the path generator is about to + // add one. + std::string prefix = prefix_in.substr(0, prefix_in.size()-1); + + // PREFIX/(cmake|CMake)/ (useful on windows or in build trees) + { + cmFindPackageFileList lister(this); + lister + / cmFileListGeneratorFixed(prefix) + / cmFileListGeneratorCaseInsensitive("cmake"); + if(lister.Search()) + { + return true; + } + } + + // PREFIX/(share|lib)/(Foo|foo|FOO).*/ + { + cmFindPackageFileList lister(this); + lister + / cmFileListGeneratorFixed(prefix) + / cmFileListGeneratorEnumerate("lib", "share") + / cmFileListGeneratorProject(this->Names); + if(lister.Search()) + { + return true; + } + } + + // PREFIX/(share|lib)/(Foo|foo|FOO).*/(cmake|CMake)/ + { + cmFindPackageFileList lister(this); + lister + / cmFileListGeneratorFixed(prefix) + / cmFileListGeneratorEnumerate("lib", "share") + / cmFileListGeneratorProject(this->Names) + / cmFileListGeneratorCaseInsensitive("cmake"); + if(lister.Search()) + { + return true; + } + } + + return false; +} + +//---------------------------------------------------------------------------- +bool cmFindPackageCommand::SearchFrameworkPrefix(std::string const& prefix_in) +{ + assert(!prefix_in.empty() && prefix_in[prefix_in.size()-1] == '/'); + if(this->DebugMode) + { + fprintf(stderr, "Checking framework prefix [%s]\n", prefix_in.c_str()); + } + + // Strip the trailing slash because the path generator is about to + // add one. + std::string prefix = prefix_in.substr(0, prefix_in.size()-1); + + // <prefix>/Foo.framework/Resources/ + { + cmFindPackageFileList lister(this); + lister + / cmFileListGeneratorFixed(prefix) + / cmFileListGeneratorMacProject(this->Names, ".framework") + / cmFileListGeneratorFixed("Resources"); + if(lister.Search()) + { + return true; + } + } + // <prefix>/Foo.framework/Resources/CMake/ + { + cmFindPackageFileList lister(this); + lister + / cmFileListGeneratorFixed(prefix) + / cmFileListGeneratorMacProject(this->Names, ".framework") + / cmFileListGeneratorFixed("Resources") + / cmFileListGeneratorCaseInsensitive("cmake"); + if(lister.Search()) + { + return true; + } + } + + // <prefix>/Foo.framework/Versions/*/Resources/ + { + cmFindPackageFileList lister(this); + lister + / cmFileListGeneratorFixed(prefix) + / cmFileListGeneratorMacProject(this->Names, ".framework") + / cmFileListGeneratorFixed("Versions") + / cmFileListGeneratorGlob("*/Resources"); + if(lister.Search()) + { + return true; + } + } + + // <prefix>/Foo.framework/Versions/*/Resources/CMake/ + { + cmFindPackageFileList lister(this); + lister + / cmFileListGeneratorFixed(prefix) + / cmFileListGeneratorMacProject(this->Names, ".framework") + / cmFileListGeneratorFixed("Versions") + / cmFileListGeneratorGlob("*/Resources") + / cmFileListGeneratorCaseInsensitive("cmake"); + if(lister.Search()) + { + return true; + } + } + + return false; +} + +//---------------------------------------------------------------------------- +bool cmFindPackageCommand::SearchAppBundlePrefix(std::string const& prefix_in) +{ + assert(!prefix_in.empty() && prefix_in[prefix_in.size()-1] == '/'); + if(this->DebugMode) + { + fprintf(stderr, "Checking bundle prefix [%s]\n", prefix_in.c_str()); + } + + // Strip the trailing slash because the path generator is about to + // add one. + std::string prefix = prefix_in.substr(0, prefix_in.size()-1); + + // <prefix>/Foo.app/Contents/Resources + { + cmFindPackageFileList lister(this); + lister + / cmFileListGeneratorFixed(prefix) + / cmFileListGeneratorMacProject(this->Names, ".app") + / cmFileListGeneratorFixed("Contents/Resources"); + if(lister.Search()) + { + return true; + } + } + + // <prefix>/Foo.app/Contents/Resources/CMake + { + cmFindPackageFileList lister(this); + lister + / cmFileListGeneratorFixed(prefix) + / cmFileListGeneratorMacProject(this->Names, ".app") + / cmFileListGeneratorFixed("Contents/Resources") + / cmFileListGeneratorCaseInsensitive("cmake"); + if(lister.Search()) + { + return true; + } + } + + return false; +} + +// TODO: Version numbers? Perhaps have a listing component class that +// sorts by lexicographic and numerical ordering. Also try to match +// some command argument for the version. Alternatively provide an +// API that just returns a list of valid directories? Perhaps push a +// scope and try loading the target file just to get its version +// number? Could add a foo-version.cmake or FooVersion.cmake file +// in the projects that contains just version information. + +// TODO: Debug cmsys::Glob double slash problem. + +// TODO: Add registry entries after cmake system search path? +// Currently the user must specify them with the PATHS option. +// +// [HKEY_CURRENT_USER\Software\*\Foo*;InstallDir] +// [HKEY_CURRENT_USER\Software\*\*\Foo*;InstallDir] +// [HKEY_LOCAL_MACHINE\Software\*\Foo*;InstallDir] +// [HKEY_LOCAL_MACHINE\Software\*\*\Foo*;InstallDir] diff --git a/Source/cmFindPackageCommand.h b/Source/cmFindPackageCommand.h index 26c6090756..af4104856a 100644 --- a/Source/cmFindPackageCommand.h +++ b/Source/cmFindPackageCommand.h @@ -17,16 +17,20 @@ #ifndef cmFindPackageCommand_h #define cmFindPackageCommand_h -#include "cmCommand.h" +#include "cmFindCommon.h" + +class cmFindPackageFileList; /** \class cmFindPackageCommand * \brief Load settings from an external project. * * cmFindPackageCommand */ -class cmFindPackageCommand : public cmCommand +class cmFindPackageCommand : public cmFindCommon { public: + cmFindPackageCommand(); + /** * This is a virtual constructor for the command. */ @@ -62,51 +66,45 @@ public: /** * More documentation. */ - virtual const char* GetFullDocumentation() - { - return - " find_package(<name> [major.minor] [QUIET] [NO_MODULE]\n" - " [[REQUIRED|COMPONENTS] [components...]])\n" - "Finds and loads settings from an external project. <name>_FOUND will " - "be set to indicate whether the package was found. Settings that " - "can be used when <name>_FOUND is true are package-specific. The " - "package is found through several steps. " - "Directories listed in CMAKE_MODULE_PATH are searched for files called " - "\"Find<name>.cmake\". If such a file is found, it is read and " - "processed by CMake, and is responsible for finding the package. " - "This first step may be skipped by using the NO_MODULE option. " - "If no such file is found, it is expected that the package is another " - "project built by CMake that has a \"<name>Config.cmake\" file. " - "A cache entry called <name>_DIR is created and is expected to be set " - "to the directory containing this file. If the file is found, it is " - "read and processed by CMake to load the settings of the package. If " - "<name>_DIR has not been set during a configure step, the command " - "will generate an error describing the problem unless the QUIET " - "argument is specified. If <name>_DIR has been set to a directory " - "not containing a \"<name>Config.cmake\" file, an error is always " - "generated. If REQUIRED is specified and the package is not found, " - "a FATAL_ERROR is generated and the configure step stops executing. " - "A package-specific list of components may be listed after the " - "REQUIRED option, or after the COMPONENTS option if no REQUIRED " - "option is given."; - } + virtual const char* GetFullDocumentation(); - cmTypeMacro(cmFindPackageCommand, cmCommand); + cmTypeMacro(cmFindPackageCommand, cmFindCommon); private: - void AppendSuccessInformation(bool quiet); + void AppendSuccessInformation(); void AppendToProperty(const char* propertyName); - bool FindModule(bool& found, bool quiet, bool required); - bool FindConfig(); - std::string SearchForConfig() const; + bool FindModule(bool& found); + bool HandlePackageMode(); + void FindConfig(); + bool FindPrefixedConfig(); + bool FindFrameworkConfig(); + bool FindAppBundleConfig(); bool ReadListFile(const char* f); + void AddUserPath(std::string const& p); + void ComputePrefixes(); + bool SearchDirectory(std::string const& dir); + bool CheckDirectory(std::string const& dir); + bool FindConfigFile(std::string const& dir, std::string& file); + bool SearchPrefix(std::string const& prefix); + bool SearchFrameworkPrefix(std::string const& prefix_in); + bool SearchAppBundlePrefix(std::string const& prefix_in); + + friend class cmFindPackageFileList; + + std::string CommandDocumentation; cmStdString Name; cmStdString Variable; - cmStdString Config; - std::vector<cmStdString> Builds; - std::vector<cmStdString> Prefixes; - std::vector<cmStdString> Relatives; + cmStdString FileFound; + bool Quiet; + bool Required; + bool Compatibility_1_6; + bool NoModule; + bool NoBuilds; + bool DebugMode; + std::vector<std::string> Names; + std::vector<std::string> Configs; + std::vector<std::string> Prefixes; + std::vector<std::string> UserPaths; }; - #endif diff --git a/Source/cmFindPathCommand.cxx b/Source/cmFindPathCommand.cxx index 00c08ec2bd..f322b43f4f 100644 --- a/Source/cmFindPathCommand.cxx +++ b/Source/cmFindPathCommand.cxx @@ -28,6 +28,12 @@ cmFindPathCommand::cmFindPathCommand() cmSystemTools::ReplaceString(this->GenericDocumentation, "CMAKE_XXX_PATH", "CMAKE_INCLUDE_PATH"); cmSystemTools::ReplaceString(this->GenericDocumentation, + "CMAKE_XXX_MAC_PATH", + "CMAKE_FRAMEWORK_PATH"); + cmSystemTools::ReplaceString(this->GenericDocumentation, + "CMAKE_SYSTEM_XXX_MAC_PATH", + "CMAKE_SYSTEM_FRAMEWORK_PATH"); + cmSystemTools::ReplaceString(this->GenericDocumentation, "XXX_SYSTEM", "INCLUDE"); cmSystemTools::ReplaceString(this->GenericDocumentation, "CMAKE_SYSTEM_XXX_PATH", diff --git a/Source/cmFindProgramCommand.cxx b/Source/cmFindProgramCommand.cxx index fb563e285c..318dc134b8 100644 --- a/Source/cmFindProgramCommand.cxx +++ b/Source/cmFindProgramCommand.cxx @@ -29,6 +29,12 @@ cmFindProgramCommand::cmFindProgramCommand() cmSystemTools::ReplaceString(this->GenericDocumentation, "CMAKE_XXX_PATH", "CMAKE_PROGRAM_PATH"); cmSystemTools::ReplaceString(this->GenericDocumentation, + "CMAKE_XXX_MAC_PATH", + "CMAKE_APPBUNDLE_PATH"); + cmSystemTools::ReplaceString(this->GenericDocumentation, + "CMAKE_SYSTEM_XXX_MAC_PATH", + "CMAKE_SYSTEM_APPBUNDLE_PATH"); + cmSystemTools::ReplaceString(this->GenericDocumentation, "XXX_SYSTEM", ""); cmSystemTools::ReplaceString(this->GenericDocumentation, "CMAKE_SYSTEM_XXX_PATH", |