summaryrefslogtreecommitdiff
path: root/Source/cmFindPackageCommand.cxx
diff options
context:
space:
mode:
authorAnas Nashif <anas.nashif@intel.com>2012-10-30 22:39:57 (GMT)
committerAnas Nashif <anas.nashif@intel.com>2012-10-30 22:39:57 (GMT)
commit035c7fabc3b82cbc9a346c11abe2e9462b4c0379 (patch)
tree7e40f5a790eae329a8c5d3e59f046451767956ff /Source/cmFindPackageCommand.cxx
downloadcmake-035c7fabc3b82cbc9a346c11abe2e9462b4c0379.zip
cmake-035c7fabc3b82cbc9a346c11abe2e9462b4c0379.tar.gz
cmake-035c7fabc3b82cbc9a346c11abe2e9462b4c0379.tar.bz2
Imported Upstream version 2.8.9upstream/2.8.9
Diffstat (limited to 'Source/cmFindPackageCommand.cxx')
-rw-r--r--Source/cmFindPackageCommand.cxx2636
1 files changed, 2636 insertions, 0 deletions
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
new file mode 100644
index 0000000..be47f95
--- /dev/null
+++ b/Source/cmFindPackageCommand.cxx
@@ -0,0 +1,2636 @@
+/*============================================================================
+ CMake - Cross Platform Makefile Generator
+ Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+ Distributed under the OSI-approved BSD License (the "License");
+ see accompanying file Copyright.txt for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even the
+ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the License for more information.
+============================================================================*/
+#include "cmFindPackageCommand.h"
+
+#include <cmsys/Directory.hxx>
+#include <cmsys/RegularExpression.hxx>
+
+#ifdef CMAKE_BUILD_WITH_CMAKE
+#include "cmVariableWatch.h"
+#endif
+
+#if defined(__HAIKU__)
+#include <StorageKit.h>
+#endif
+
+void cmFindPackageNeedBackwardsCompatibility(const std::string& variable,
+ int access_type, void*, const char* newValue,
+ const cmMakefile*)
+{
+ (void)newValue;
+#ifdef CMAKE_BUILD_WITH_CMAKE
+ if(access_type == cmVariableWatch::UNKNOWN_VARIABLE_READ_ACCESS)
+ {
+ std::string message = "An attempt was made to access a variable: ";
+ message += variable;
+ message +=
+ " that has not been defined. This variable is created by the "
+ "FIND_PACKAGE command. CMake version 1.6 always converted the "
+ "variable name to upper-case, but this behavior is no longer the "
+ "case. To fix this you might need to set the cache value of "
+ "CMAKE_BACKWARDS_COMPATIBILITY to 1.6 or less. If you are writing a "
+ "CMake listfile, you should change the variable reference to use "
+ "the case of the argument to FIND_PACKAGE.";
+ cmSystemTools::Error(message.c_str());
+ }
+#else
+ (void)variable;
+ (void)access_type;
+#endif
+}
+
+//----------------------------------------------------------------------------
+cmFindPackageCommand::cmFindPackageCommand()
+{
+ this->CMakePathName = "PACKAGE";
+ this->Quiet = false;
+ this->Required = false;
+ this->NoUserRegistry = false;
+ this->NoSystemRegistry = false;
+ this->NoBuilds = false;
+ this->UseConfigFiles = true;
+ this->UseFindModules = true;
+ this->DebugMode = false;
+ this->UseLib64Paths = false;
+ this->PolicyScope = true;
+ this->VersionMajor = 0;
+ this->VersionMinor = 0;
+ this->VersionPatch = 0;
+ this->VersionTweak = 0;
+ this->VersionCount = 0;
+ this->VersionExact = false;
+ this->VersionFoundMajor = 0;
+ this->VersionFoundMinor = 0;
+ this->VersionFoundPatch = 0;
+ this->VersionFoundTweak = 0;
+ this->VersionFoundCount = 0;
+ this->RequiredCMakeVersion = 0;
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::GenerateDocumentation()
+{
+ this->cmFindCommon::GenerateDocumentation();
+ 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->CommandDocumentation =
+ " find_package(<package> [version] [EXACT] [QUIET] [MODULE]\n"
+ " [REQUIRED] [[COMPONENTS] [components...]]\n"
+ " [OPTIONAL_COMPONENTS components...]\n"
+ " [NO_POLICY_SCOPE])\n"
+ "Finds and loads settings from an external project. "
+ "<package>_FOUND will be set to indicate whether the package was found. "
+ "When the package is found package-specific information is provided "
+ "through variables documented by the package itself. "
+ "The QUIET option disables messages if the package cannot be found. "
+ "The MODULE option disables the second signature documented below. "
+ "The REQUIRED option stops processing with an error message if the "
+ "package cannot be found."
+ "\n"
+ "A package-specific list of required components may be listed after the "
+ "COMPONENTS option (or after the REQUIRED option if present). "
+ "Additional optional components may be listed after OPTIONAL_COMPONENTS. "
+ "Available components and their influence on whether a package is "
+ "considered to be found are defined by the target package."
+ "\n"
+ "The [version] argument requests a version with which the package found "
+ "should be compatible (format is major[.minor[.patch[.tweak]]]). "
+ "The EXACT option requests that the version be matched exactly. "
+ "If no [version] and/or component list is given to a recursive "
+ "invocation inside a find-module, the corresponding arguments "
+ "are forwarded automatically from the outer call (including the "
+ "EXACT flag for [version]). "
+ "Version support is currently provided only on a package-by-package "
+ "basis (details below).\n"
+ "User code should generally look for packages using the above simple "
+ "signature. The remainder of this command documentation specifies the "
+ "full command signature and details of the search process. Project "
+ "maintainers wishing to provide a package to be found by this command "
+ "are encouraged to read on.\n"
+ "The command has two modes by which it searches for packages: "
+ "\"Module\" mode and \"Config\" mode. "
+ "Module mode is available when the command is invoked with the above "
+ "reduced signature. "
+ "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, checking the version, "
+ "and producing any needed messages. "
+ "Many find-modules provide limited or no support for versioning; "
+ "check the module documentation. "
+ "If no module is found and the MODULE option is not given the command "
+ "proceeds to Config mode.\n"
+ "The complete Config mode command signature is:\n"
+ " find_package(<package> [version] [EXACT] [QUIET]\n"
+ " [REQUIRED] [[COMPONENTS] [components...]]\n"
+ " [CONFIG|NO_MODULE]\n"
+ " [NO_POLICY_SCOPE]\n"
+ " [NAMES name1 [name2 ...]]\n"
+ " [CONFIGS config1 [config2 ...]]\n"
+ " [HINTS path1 [path2 ... ]]\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_PACKAGE_REGISTRY]\n"
+ " [NO_CMAKE_BUILDS_PATH]\n"
+ " [NO_CMAKE_SYSTEM_PATH]\n"
+ " [NO_CMAKE_SYSTEM_PACKAGE_REGISTRY]\n"
+ " [CMAKE_FIND_ROOT_PATH_BOTH |\n"
+ " ONLY_CMAKE_FIND_ROOT_PATH |\n"
+ " NO_CMAKE_FIND_ROOT_PATH])\n"
+ "The CONFIG option may be used to skip Module mode explicitly and "
+ "switch to Config mode. It is synonymous to using NO_MODULE. "
+ "Config mode is also 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"
+ "All configuration files which have been considered by CMake while "
+ "searching for an installation of the package with an appropriate "
+ "version are stored in the cmake variable <package>_CONSIDERED_CONFIGS, "
+ "the associated versions in <package>_CONSIDERED_VERSIONS. "
+ "\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 CMake will ignore it and search from scratch."
+ "\n"
+ "When the [version] argument is given Config mode will only find a "
+ "version of the package that claims compatibility with the requested "
+ "version (format is major[.minor[.patch[.tweak]]]). "
+ "If the EXACT option is given only a version of the package claiming "
+ "an exact match of the requested version may be found. "
+ "CMake does not establish any convention for the meaning of version "
+ "numbers. "
+ "Package version numbers are checked by \"version\" files provided by "
+ "the packages themselves. "
+ "For a candidate package configuration file \"<config-file>.cmake\" the "
+ "corresponding version file is located next to it and named either "
+ "\"<config-file>-version.cmake\" or \"<config-file>Version.cmake\". "
+ "If no such version file is available then the configuration file "
+ "is assumed to not be compatible with any requested version. "
+ "A basic version file containing generic version matching code can be "
+ "created using the macro write_basic_package_version_file(), see its "
+ "documentation for more details. "
+ "When a version file is found it is loaded to check the requested "
+ "version number. "
+ "The version file is loaded in a nested scope in which the following "
+ "variables have been defined:\n"
+ " PACKAGE_FIND_NAME = the <package> name\n"
+ " PACKAGE_FIND_VERSION = full requested version string\n"
+ " PACKAGE_FIND_VERSION_MAJOR = major version if requested, else 0\n"
+ " PACKAGE_FIND_VERSION_MINOR = minor version if requested, else 0\n"
+ " PACKAGE_FIND_VERSION_PATCH = patch version if requested, else 0\n"
+ " PACKAGE_FIND_VERSION_TWEAK = tweak version if requested, else 0\n"
+ " PACKAGE_FIND_VERSION_COUNT = number of version components, 0 to 4\n"
+ "The version file checks whether it satisfies the requested version "
+ "and sets these variables:\n"
+ " PACKAGE_VERSION = full provided version string\n"
+ " PACKAGE_VERSION_EXACT = true if version is exact match\n"
+ " PACKAGE_VERSION_COMPATIBLE = true if version is compatible\n"
+ " PACKAGE_VERSION_UNSUITABLE = true if unsuitable as any version\n"
+ "These variables are checked by the find_package command to determine "
+ "whether the configuration file provides an acceptable version. "
+ "They are not available after the find_package call returns. "
+ "If the version is acceptable the following variables are set:\n"
+ " <package>_VERSION = full provided version string\n"
+ " <package>_VERSION_MAJOR = major version if provided, else 0\n"
+ " <package>_VERSION_MINOR = minor version if provided, else 0\n"
+ " <package>_VERSION_PATCH = patch version if provided, else 0\n"
+ " <package>_VERSION_TWEAK = tweak version if provided, else 0\n"
+ " <package>_VERSION_COUNT = number of version components, 0 to 4\n"
+ "and the corresponding package configuration file is loaded. "
+ "When multiple package configuration files are available whose version "
+ "files claim compatibility with the version requested it is unspecified "
+ "which one is chosen. "
+ "No attempt is made to choose a highest or closest version number."
+ "\n"
+ "Config mode provides an elaborate interface and search procedure. "
+ "Much of the interface is provided for completeness and for use "
+ "internally by find-modules loaded by Module mode. "
+ "Most user code should simply call\n"
+ " find_package(<package> [major[.minor]] [EXACT] [REQUIRED|QUIET])\n"
+ "in order to find a package. Package maintainers providing CMake "
+ "package configuration files are encouraged to name and install "
+ "them such that the procedure outlined below will find them "
+ "without requiring use of additional options."
+ "\n"
+ "CMake constructs a set of possible installation prefixes for the "
+ "package. Under each prefix several directories are searched for a "
+ "configuration file. The tables below show the directories searched. "
+ "Each entry is meant for installation trees following Windows (W), "
+ "UNIX (U), or Apple (A) conventions.\n"
+ " <prefix>/ (W)\n"
+ " <prefix>/(cmake|CMake)/ (W)\n"
+ " <prefix>/<name>*/ (W)\n"
+ " <prefix>/<name>*/(cmake|CMake)/ (W)\n"
+ " <prefix>/(lib/<arch>|lib|share)/cmake/<name>*/ (U)\n"
+ " <prefix>/(lib/<arch>|lib|share)/<name>*/ (U)\n"
+ " <prefix>/(lib/<arch>|lib|share)/<name>*/(cmake|CMake)/ (U)\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). "
+ "Paths with lib/<arch> are enabled if CMAKE_LIBRARY_ARCHITECTURE is set. "
+ "If PATH_SUFFIXES is specified the suffixes are appended to each "
+ "(W) or (U) 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 (U) are intended for "
+ "installations on UNIX platforms where the prefix is shared by "
+ "multiple packages. This is merely a convention, so all (W) and (U) "
+ "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 all NO_* options are enabled.\n"
+ "1. Search paths specified in cmake-specific cache 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"
+ "2. Search paths specified in cmake-specific environment variables. "
+ "These are intended to be set in the user's shell configuration. "
+ "This can be skipped if NO_CMAKE_ENVIRONMENT_PATH is passed.\n"
+ " <package>_DIR\n"
+ " CMAKE_PREFIX_PATH\n"
+ " CMAKE_FRAMEWORK_PATH\n"
+ " CMAKE_APPBUNDLE_PATH\n"
+ "3. Search paths specified by the HINTS option. "
+ "These should be paths computed by system introspection, such as a "
+ "hint provided by the location of another item already found. "
+ "Hard-coded guesses should be specified with the PATHS option.\n"
+ "4. 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"
+ "5. 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"
+ "6. Search paths stored in the CMake user package registry. "
+ "This can be skipped if NO_CMAKE_PACKAGE_REGISTRY is passed. "
+ "On Windows a <package> may appear under registry key\n"
+ " HKEY_CURRENT_USER\\Software\\Kitware\\CMake\\Packages\\<package>\n"
+ "as a REG_SZ value, with arbitrary name, that specifies the directory "
+ "containing the package configuration file. "
+ "On UNIX platforms a <package> may appear under the directory\n"
+ " ~/.cmake/packages/<package>\n"
+ "as a file, with arbitrary name, whose content specifies the directory "
+ "containing the package configuration file. "
+ "See the export(PACKAGE) command to create user package registry entries "
+ "for project build trees."
+ "\n"
+ "7. 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"
+ "8. Search paths stored in the CMake system package registry. "
+ "This can be skipped if NO_CMAKE_SYSTEM_PACKAGE_REGISTRY is passed. "
+ "On Windows a <package> may appear under registry key\n"
+ " HKEY_LOCAL_MACHINE\\Software\\Kitware\\CMake\\Packages\\<package>\n"
+ "as a REG_SZ value, with arbitrary name, that specifies the directory "
+ "containing the package configuration file. "
+ "There is no system package registry on non-Windows platforms."
+ "\n"
+ "9. Search paths specified by the PATHS option. "
+ "These are typically hard-coded guesses.\n"
+ ;
+ this->CommandDocumentation += this->GenericDocumentationMacPolicy;
+ this->CommandDocumentation += this->GenericDocumentationRootPath;
+ this->CommandDocumentation += this->GenericDocumentationPathsOrder;
+ this->CommandDocumentation +=
+ "\n"
+ "Every non-REQUIRED find_package() call can be disabled by setting the "
+ "variable CMAKE_DISABLE_FIND_PACKAGE_<package> to TRUE. See the "
+ "documentation for the CMAKE_DISABLE_FIND_PACKAGE_<package> variable for "
+ "more information.\n"
+ "When loading a find module or package configuration file find_package "
+ "defines variables to provide information about the call arguments "
+ "(and restores their original state before returning):\n"
+ " <package>_FIND_REQUIRED = true if REQUIRED option was given\n"
+ " <package>_FIND_QUIETLY = true if QUIET option was given\n"
+ " <package>_FIND_VERSION = full requested version string\n"
+ " <package>_FIND_VERSION_MAJOR = major version if requested, else 0\n"
+ " <package>_FIND_VERSION_MINOR = minor version if requested, else 0\n"
+ " <package>_FIND_VERSION_PATCH = patch version if requested, else 0\n"
+ " <package>_FIND_VERSION_TWEAK = tweak version if requested, else 0\n"
+ " <package>_FIND_VERSION_COUNT = number of version components, 0 to 4\n"
+ " <package>_FIND_VERSION_EXACT = true if EXACT option was given\n"
+ " <package>_FIND_COMPONENTS = list of requested components\n"
+ " <package>_FIND_REQUIRED_<c> = true if component <c> is required\n"
+ " false if component <c> is optional\n"
+ "In Module mode the loaded find module is responsible to honor the "
+ "request detailed by these variables; see the find module for details. "
+ "In Config mode find_package handles REQUIRED, QUIET, and version "
+ "options automatically but leaves it to the package configuration file "
+ "to handle components in a way that makes sense for the package. "
+ "The package configuration file may set <package>_FOUND to false "
+ "to tell find_package that component requirements are not satisfied."
+ "\n"
+ "See the cmake_policy() command documentation for discussion of the "
+ "NO_POLICY_SCOPE option."
+ ;
+}
+
+//----------------------------------------------------------------------------
+const char* cmFindPackageCommand::GetFullDocumentation() const
+{
+ if(this->CommandDocumentation.empty())
+ {
+ const_cast<cmFindPackageCommand *>(this)->GenerateDocumentation();
+ }
+ return this->CommandDocumentation.c_str();
+}
+
+//----------------------------------------------------------------------------
+bool cmFindPackageCommand
+::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+{
+ if(args.size() < 1)
+ {
+ this->SetError("called with incorrect number of arguments");
+ return false;
+ }
+
+ // Lookup required version of CMake.
+ if(const char* rv =
+ this->Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION"))
+ {
+ unsigned int v[3] = {0,0,0};
+ sscanf(rv, "%u.%u.%u", &v[0], &v[1], &v[2]);
+ this->RequiredCMakeVersion = CMake_VERSION_ENCODE(v[0],v[1],v[2]);
+ }
+
+ // Check for debug mode.
+ this->DebugMode = this->Makefile->IsOn("CMAKE_FIND_DEBUG_MODE");
+
+ // Lookup target architecture, if any.
+ if(const char* arch =
+ this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE"))
+ {
+ this->LibraryArchitecture = arch;
+ }
+
+ // Lookup whether lib64 paths should be used.
+ if(this->Makefile->PlatformIs64Bit() &&
+ this->Makefile->GetCMakeInstance()
+ ->GetPropertyAsBool("FIND_LIBRARY_USE_LIB64_PATHS"))
+ {
+ this->UseLib64Paths = true;
+ }
+
+ // Find the current root path mode.
+ this->SelectDefaultRootPathMode();
+
+ // Find the current bundle/framework search policy.
+ this->SelectDefaultMacMode();
+
+ // Record options.
+ this->Name = args[0];
+ std::string components;
+ const char* components_sep = "";
+ std::set<std::string> requiredComponents;
+ std::set<std::string> optionalComponents;
+
+ // 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.
+ enum Doing { DoingNone, DoingComponents, DoingOptionalComponents, DoingNames,
+ DoingPaths, DoingPathSuffixes, DoingConfigs, DoingHints };
+ Doing doing = DoingNone;
+ cmsys::RegularExpression version("^[0-9.]+$");
+ bool haveVersion = false;
+ std::set<unsigned int> configArgs;
+ std::set<unsigned int> moduleArgs;
+ for(unsigned int i=1; i < args.size(); ++i)
+ {
+ if(args[i] == "QUIET")
+ {
+ this->Quiet = true;
+ doing = DoingNone;
+ }
+ else if(args[i] == "EXACT")
+ {
+ this->VersionExact = true;
+ this->Compatibility_1_6 = false;
+ doing = DoingNone;
+ }
+ else if(args[i] == "MODULE")
+ {
+ moduleArgs.insert(i);
+ doing = DoingNone;
+ }
+ else if(args[i] == "CONFIG")
+ {
+ configArgs.insert(i);
+ doing = DoingNone;
+ }
+ else if(args[i] == "NO_MODULE")
+ {
+ configArgs.insert(i);
+ doing = DoingNone;
+ }
+ else if(args[i] == "REQUIRED")
+ {
+ this->Required = true;
+ doing = DoingComponents;
+ }
+ else if(args[i] == "COMPONENTS")
+ {
+ this->Compatibility_1_6 = false;
+ doing = DoingComponents;
+ }
+ else if(args[i] == "OPTIONAL_COMPONENTS")
+ {
+ this->Compatibility_1_6 = false;
+ doing = DoingOptionalComponents;
+ }
+ else if(args[i] == "NAMES")
+ {
+ configArgs.insert(i);
+ this->Compatibility_1_6 = false;
+ doing = DoingNames;
+ }
+ else if(args[i] == "PATHS")
+ {
+ configArgs.insert(i);
+ this->Compatibility_1_6 = false;
+ doing = DoingPaths;
+ }
+ else if(args[i] == "HINTS")
+ {
+ configArgs.insert(i);
+ this->Compatibility_1_6 = false;
+ doing = DoingHints;
+ }
+ else if(args[i] == "PATH_SUFFIXES")
+ {
+ configArgs.insert(i);
+ this->Compatibility_1_6 = false;
+ doing = DoingPathSuffixes;
+ }
+ else if(args[i] == "CONFIGS")
+ {
+ configArgs.insert(i);
+ this->Compatibility_1_6 = false;
+ doing = DoingConfigs;
+ }
+ else if(args[i] == "NO_POLICY_SCOPE")
+ {
+ this->PolicyScope = false;
+ this->Compatibility_1_6 = false;
+ doing = DoingNone;
+ }
+ else if(args[i] == "NO_CMAKE_PACKAGE_REGISTRY")
+ {
+ this->NoUserRegistry = true;
+ configArgs.insert(i);
+ this->Compatibility_1_6 = false;
+ doing = DoingNone;
+ }
+ else if(args[i] == "NO_CMAKE_SYSTEM_PACKAGE_REGISTRY")
+ {
+ this->NoSystemRegistry = true;
+ configArgs.insert(i);
+ this->Compatibility_1_6 = false;
+ doing = DoingNone;
+ }
+ else if(args[i] == "NO_CMAKE_BUILDS_PATH")
+ {
+ this->NoBuilds = true;
+ configArgs.insert(i);
+ this->Compatibility_1_6 = false;
+ doing = DoingNone;
+ }
+ else if(this->CheckCommonArgument(args[i]))
+ {
+ configArgs.insert(i);
+ this->Compatibility_1_6 = false;
+ doing = DoingNone;
+ }
+ else if((doing == DoingComponents) || (doing == DoingOptionalComponents))
+ {
+ // Set a variable telling the find script whether this component
+ // is required.
+ const char* isRequired = "1";
+ if (doing == DoingOptionalComponents)
+ {
+ isRequired = "0";
+ optionalComponents.insert(args[i]);
+ }
+ else
+ {
+ requiredComponents.insert(args[i]);
+ }
+
+ std::string req_var = this->Name + "_FIND_REQUIRED_" + args[i];
+ this->AddFindDefinition(req_var.c_str(), isRequired);
+
+ // Append to the list of required components.
+ components += components_sep;
+ components += args[i];
+ components_sep = ";";
+ }
+ else if(doing == DoingNames)
+ {
+ this->Names.push_back(args[i]);
+ }
+ else if(doing == DoingPaths)
+ {
+ this->AddUserPath(args[i], this->UserPaths);
+ }
+ else if(doing == DoingHints)
+ {
+ this->AddUserPath(args[i], this->UserHints);
+ }
+ else if(doing == DoingPathSuffixes)
+ {
+ this->AddPathSuffix(args[i]);
+ }
+ else if(doing == DoingConfigs)
+ {
+ if(args[i].find_first_of(":/\\") != args[i].npos ||
+ cmSystemTools::GetFilenameLastExtension(args[i]) != ".cmake")
+ {
+ cmOStringStream e;
+ e << "given CONFIGS option followed by invalid file name \""
+ << args[i] << "\". The names given must be file names without "
+ << "a path and with a \".cmake\" extension.";
+ this->SetError(e.str().c_str());
+ return false;
+ }
+ this->Configs.push_back(args[i]);
+ }
+ else if(!haveVersion && version.find(args[i].c_str()))
+ {
+ haveVersion = true;
+ this->Version = args[i];
+ }
+ else
+ {
+ cmOStringStream e;
+ e << "called with invalid argument \"" << args[i].c_str() << "\"";
+ this->SetError(e.str().c_str());
+ return false;
+ }
+ }
+
+ std::vector<std::string> doubledComponents;
+ std::set_intersection(requiredComponents.begin(), requiredComponents.end(),
+ optionalComponents.begin(), optionalComponents.end(),
+ std::back_inserter(doubledComponents));
+ if(!doubledComponents.empty())
+ {
+ cmOStringStream e;
+ e << "called with components that are both required and optional:\n";
+ for(unsigned int i=0; i<doubledComponents.size(); ++i)
+ {
+ e << " " << doubledComponents[i] << "\n";
+ }
+ this->SetError(e.str().c_str());
+ return false;
+ }
+
+ // Maybe choose one mode exclusively.
+ this->UseFindModules = configArgs.empty();
+ this->UseConfigFiles = moduleArgs.empty();
+ if(!this->UseFindModules && !this->UseConfigFiles)
+ {
+ cmOStringStream e;
+ e << "given options exclusive to Module mode:\n";
+ for(std::set<unsigned int>::const_iterator si = moduleArgs.begin();
+ si != moduleArgs.end(); ++si)
+ {
+ e << " " << args[*si] << "\n";
+ }
+ e << "and options exclusive to Config mode:\n";
+ for(std::set<unsigned int>::const_iterator si = configArgs.begin();
+ si != configArgs.end(); ++si)
+ {
+ e << " " << args[*si] << "\n";
+ }
+ e << "The options are incompatible.";
+ this->SetError(e.str().c_str());
+ return false;
+ }
+
+ // Ignore EXACT with no version.
+ if(this->Version.empty() && this->VersionExact)
+ {
+ this->VersionExact = false;
+ this->Makefile->IssueMessage(
+ cmake::AUTHOR_WARNING, "Ignoring EXACT since no version is requested.");
+ }
+
+ if(this->Version.empty() || components.empty())
+ {
+ // Check whether we are recursing inside "Find<name>.cmake" within
+ // another find_package(<name>) call.
+ std::string mod = this->Name;
+ mod += "_FIND_MODULE";
+ if(this->Makefile->IsOn(mod.c_str()))
+ {
+ if(this->Version.empty())
+ {
+ // Get version information from the outer call if necessary.
+ // Requested version string.
+ std::string ver = this->Name;
+ ver += "_FIND_VERSION";
+ this->Version = this->Makefile->GetSafeDefinition(ver.c_str());
+
+ // Whether an exact version is required.
+ std::string exact = this->Name;
+ exact += "_FIND_VERSION_EXACT";
+ this->VersionExact = this->Makefile->IsOn(exact.c_str());
+ }
+ if(components.empty())
+ {
+ std::string components_var = this->Name + "_FIND_COMPONENTS";
+ components = this->Makefile->GetSafeDefinition(components_var.c_str());
+ }
+ }
+ }
+
+ if(!this->Version.empty())
+ {
+ // Try to parse the version number and store the results that were
+ // successfully parsed.
+ unsigned int parsed_major;
+ unsigned int parsed_minor;
+ unsigned int parsed_patch;
+ unsigned int parsed_tweak;
+ this->VersionCount = sscanf(this->Version.c_str(), "%u.%u.%u.%u",
+ &parsed_major, &parsed_minor,
+ &parsed_patch, &parsed_tweak);
+ switch(this->VersionCount)
+ {
+ case 4: this->VersionTweak = parsed_tweak; // no break!
+ case 3: this->VersionPatch = parsed_patch; // no break!
+ case 2: this->VersionMinor = parsed_minor; // no break!
+ case 1: this->VersionMajor = parsed_major; // no break!
+ default: break;
+ }
+ }
+
+ std::string disableFindPackageVar = "CMAKE_DISABLE_FIND_PACKAGE_";
+ disableFindPackageVar += this->Name;
+ if(this->Makefile->IsOn(disableFindPackageVar.c_str()))
+ {
+ if (this->Required)
+ {
+ cmOStringStream e;
+ e << "for module " << this->Name << " called with REQUIRED, but "
+ << disableFindPackageVar
+ << " is enabled. A REQUIRED package cannot be disabled.";
+ this->SetError(e.str().c_str());
+ return false;
+ }
+
+ return true;
+ }
+
+
+ this->SetModuleVariables(components);
+
+ // See if there is a Find<package>.cmake module.
+ if(this->UseFindModules)
+ {
+ bool foundModule = false;
+ if(!this->FindModule(foundModule))
+ {
+ this->AppendSuccessInformation();
+ return false;
+ }
+ if(foundModule)
+ {
+ this->AppendSuccessInformation();
+ return true;
+ }
+ }
+
+ if(this->UseFindModules && this->UseConfigFiles &&
+ this->Makefile->IsOn("CMAKE_FIND_PACKAGE_WARN_NO_MODULE"))
+ {
+ cmOStringStream aw;
+ if(this->RequiredCMakeVersion >= CMake_VERSION_ENCODE(2,8,8))
+ {
+ aw << "find_package called without either MODULE or CONFIG option and "
+ "no Find" << this->Name << ".cmake module is in CMAKE_MODULE_PATH. "
+ "Add MODULE to exclusively request Module mode and fail if "
+ "Find" << this->Name << ".cmake is missing. "
+ "Add CONFIG to exclusively request Config mode and search for a "
+ "package configuration file provided by " << this->Name <<
+ " (" << this->Name << "Config.cmake or " <<
+ cmSystemTools::LowerCase(this->Name) << "-config.cmake). ";
+ }
+ else
+ {
+ aw << "find_package called without NO_MODULE option and no "
+ "Find" << this->Name << ".cmake module is in CMAKE_MODULE_PATH. "
+ "Add NO_MODULE to exclusively request Config mode and search for a "
+ "package configuration file provided by " << this->Name <<
+ " (" << this->Name << "Config.cmake or " <<
+ cmSystemTools::LowerCase(this->Name) << "-config.cmake). "
+ "Otherwise make Find" << this->Name << ".cmake available in "
+ "CMAKE_MODULE_PATH.";
+ }
+ aw << "\n"
+ "(Variable CMAKE_FIND_PACKAGE_WARN_NO_MODULE enabled this warning.)";
+ this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, aw.str());
+ }
+
+ // No find module. Assume the project has a CMake config file. Use
+ // a <package>_DIR cache variable to locate it.
+ this->Variable = this->Name;
+ this->Variable += "_DIR";
+
+ // 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);
+ }
+ }
+
+ // get igonored paths from vars and reroot them.
+ std::vector<std::string> ignored;
+ this->GetIgnoredPaths(ignored);
+ this->RerootPaths(ignored);
+
+ // Construct a set of ignored paths
+ this->IgnoredPaths.clear();
+ this->IgnoredPaths.insert(ignored.begin(), ignored.end());
+
+ // Find and load the package.
+ bool result = this->HandlePackageMode();
+ this->AppendSuccessInformation();
+ return result;
+}
+
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::SetModuleVariables(const std::string& components)
+{
+ // Store the list of components.
+ std::string components_var = this->Name + "_FIND_COMPONENTS";
+ this->AddFindDefinition(components_var.c_str(), components.c_str());
+
+ 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->AddFindDefinition(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->AddFindDefinition(req.c_str(), "1");
+ }
+
+ if(!this->Version.empty())
+ {
+ // Tell the module that is about to be read what version of the
+ // package has been requested.
+ std::string ver = this->Name;
+ ver += "_FIND_VERSION";
+ this->AddFindDefinition(ver.c_str(), this->Version.c_str());
+ char buf[64];
+ sprintf(buf, "%u", this->VersionMajor);
+ this->AddFindDefinition((ver+"_MAJOR").c_str(), buf);
+ sprintf(buf, "%u", this->VersionMinor);
+ this->AddFindDefinition((ver+"_MINOR").c_str(), buf);
+ sprintf(buf, "%u", this->VersionPatch);
+ this->AddFindDefinition((ver+"_PATCH").c_str(), buf);
+ sprintf(buf, "%u", this->VersionTweak);
+ this->AddFindDefinition((ver+"_TWEAK").c_str(), buf);
+ sprintf(buf, "%u", this->VersionCount);
+ this->AddFindDefinition((ver+"_COUNT").c_str(), buf);
+
+ // Tell the module whether an exact version has been requested.
+ std::string exact = this->Name;
+ exact += "_FIND_VERSION_EXACT";
+ this->AddFindDefinition(exact.c_str(), this->VersionExact? "1":"0");
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::AddFindDefinition(const char* var, const char* val)
+{
+ if(const char* old = this->Makefile->GetDefinition(var))
+ {
+ this->OriginalDefs[var].exists = true;
+ this->OriginalDefs[var].value = old;
+ }
+ else
+ {
+ this->OriginalDefs[var].exists = false;
+ }
+ this->Makefile->AddDefinition(var, val);
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::RestoreFindDefinitions()
+{
+ for(std::map<cmStdString, OriginalDef>::iterator
+ i = this->OriginalDefs.begin(); i != this->OriginalDefs.end(); ++i)
+ {
+ OriginalDef const& od = i->second;
+ if(od.exists)
+ {
+ this->Makefile->AddDefinition(i->first.c_str(), od.value.c_str());
+ }
+ else
+ {
+ this->Makefile->RemoveDefinition(i->first.c_str());
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+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() )
+ {
+ // Load the module we found, and set "<name>_FIND_MODULE" to true
+ // while inside it.
+ found = true;
+ std::string var = this->Name;
+ var += "_FIND_MODULE";
+ this->Makefile->AddDefinition(var.c_str(), "1");
+ bool result = this->ReadListFile(mfile.c_str(), DoPolicyScope);
+ this->Makefile->RemoveDefinition(var.c_str());
+ return result;
+ }
+ return true;
+}
+
+//----------------------------------------------------------------------------
+bool cmFindPackageCommand::HandlePackageMode()
+{
+ this->ConsideredConfigs.clear();
+
+ // Support old capitalization behavior.
+ std::string upperDir = cmSystemTools::UpperCase(this->Name);
+ std::string upperFound = cmSystemTools::UpperCase(this->Name);
+ upperDir += "_DIR";
+ upperFound += "_FOUND";
+ if(upperDir == this->Variable)
+ {
+ this->Compatibility_1_6 = false;
+ }
+
+ // Try to find the config file.
+ const char* def = this->Makefile->GetDefinition(this->Variable.c_str());
+ 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.
+ const char* oldDef = this->Makefile->GetDefinition(upperDir.c_str());
+ if(!cmSystemTools::IsOff(oldDef))
+ {
+ this->Makefile->AddDefinition(this->Variable.c_str(), oldDef);
+ def = this->Makefile->GetDefinition(this->Variable.c_str());
+ }
+ }
+
+ // Try to load the config file if the directory is known
+ bool fileFound = false;
+ if (this->UseConfigFiles)
+ {
+ if(!cmSystemTools::IsOff(def))
+ {
+ // 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()))
+ {
+ dir = "/" + dir;
+ dir = this->Makefile->GetCurrentDirectory() + dir;
+ }
+ // The file location was cached. Look for the correct file.
+ std::string file;
+ if (this->FindConfigFile(dir, file))
+ {
+ this->FileFound = file;
+ fileFound = true;
+ }
+ def = this->Makefile->GetDefinition(this->Variable.c_str());
+ }
+
+ // Search for the config file if it is not already found.
+ if(cmSystemTools::IsOff(def) || !fileFound)
+ {
+ fileFound = this->FindConfig();
+ def = this->Makefile->GetDefinition(this->Variable.c_str());
+ }
+
+ // Sanity check.
+ if(fileFound && this->FileFound.empty())
+ {
+ this->Makefile->IssueMessage(
+ cmake::INTERNAL_ERROR, "fileFound is true but FileFound is empty!");
+ fileFound = false;
+ }
+ }
+
+ std::string foundVar = this->Name;
+ foundVar += "_FOUND";
+
+ // If the directory for the config file was found, try to read the file.
+ bool result = true;
+ bool found = false;
+ bool configFileSetFOUNDFalse = false;
+
+ if(fileFound)
+ {
+ if ((this->Makefile->IsDefinitionSet(foundVar.c_str()))
+ && (this->Makefile->IsOn(foundVar.c_str()) == false))
+ {
+ // by removing Foo_FOUND here if it is FALSE, we don't really change
+ // the situation for the Config file which is about to be included,
+ // but we make it possible to detect later on whether the Config file
+ // has set Foo_FOUND to FALSE itself:
+ this->Makefile->RemoveDefinition(foundVar.c_str());
+ }
+
+ // Set the version variables before loading the config file.
+ // It may override them.
+ this->StoreVersionFound();
+
+ // Parse the configuration file.
+ if(this->ReadListFile(this->FileFound.c_str(), DoPolicyScope))
+ {
+ // The package has been found.
+ found = true;
+
+ // Check whether the Config file has set Foo_FOUND to FALSE:
+ if ((this->Makefile->IsDefinitionSet(foundVar.c_str()))
+ && (this->Makefile->IsOn(foundVar.c_str()) == false))
+ {
+ // we get here if the Config file has set Foo_FOUND actively to FALSE
+ found = false;
+ configFileSetFOUNDFalse = true;
+ }
+ }
+ else
+ {
+ // The configuration file is invalid.
+ result = false;
+ }
+ }
+
+ if (result && !found && (!this->Quiet || this->Required))
+ {
+ // The variable is not set.
+ cmOStringStream e;
+ cmOStringStream aw;
+ if (configFileSetFOUNDFalse)
+ {
+ e << "Found package configuration file:\n"
+ " " << this->FileFound << "\n"
+ "but it set " << foundVar << " to FALSE so package \"" <<
+ this->Name << "\" is considered to be NOT FOUND.";
+ }
+ // If there are files in ConsideredConfigs, it means that FooConfig.cmake
+ // have been found, but they didn't have appropriate versions.
+ else if (this->ConsideredConfigs.size() > 0)
+ {
+ e << "Could not find a configuration file for package \""
+ << this->Name << "\" that "
+ << (this->VersionExact? "exactly matches" : "is compatible with")
+ << " requested version \"" << this->Version << "\".\n"
+ << "The following configuration files were considered but not "
+ "accepted:\n";
+ for(std::vector<ConfigFileInfo>::size_type i=0;
+ i<this->ConsideredConfigs.size(); i++)
+ {
+ e << " " << this->ConsideredConfigs[i].filename
+ << ", version: " << this->ConsideredConfigs[i].version << "\n";
+ }
+ }
+ else
+ {
+ std::string requestedVersionString;
+ if(!this->Version.empty())
+ {
+ requestedVersionString = " (requested version ";
+ requestedVersionString += this->Version;
+ requestedVersionString += ")";
+ }
+
+ if (this->UseConfigFiles)
+ {
+ if(this->UseFindModules)
+ {
+ e << "By not providing \"Find" << this->Name << ".cmake\" in "
+ "CMAKE_MODULE_PATH this project has asked CMake to find a "
+ "package configuration file provided by \""<<this->Name<< "\", "
+ "but CMake did not find one.\n";
+ }
+
+ if(this->Configs.size() == 1)
+ {
+ e << "Could not find a package configuration file named \""
+ << this->Configs[0] << "\" provided by package \""
+ << this->Name << "\"" << requestedVersionString <<".\n";
+ }
+ else
+ {
+ e << "Could not find a package configuration file provided by \""
+ << this->Name << "\"" << requestedVersionString
+ << " with any of the following names:\n";
+ for(std::vector<std::string>::const_iterator ci =
+ this->Configs.begin();
+ ci != this->Configs.end(); ++ci)
+ {
+ e << " " << *ci << "\n";
+ }
+ }
+
+ e << "Add the installation prefix of \"" << this->Name << "\" to "
+ "CMAKE_PREFIX_PATH or set \"" << this->Variable << "\" to a "
+ "directory containing one of the above files. "
+ "If \"" << this->Name << "\" provides a separate development "
+ "package or SDK, be sure it has been installed.";
+ }
+ else // if(!this->UseFindModules && !this->UseConfigFiles)
+ {
+ e << "No \"Find" << this->Name << ".cmake\" found in "
+ << "CMAKE_MODULE_PATH.";
+
+ aw<< "Find"<< this->Name <<".cmake must either be part of this "
+ "project itself, in this case adjust CMAKE_MODULE_PATH so that "
+ "it points to the correct location inside its source tree.\n"
+ "Or it must be installed by a package which has already been "
+ "found via find_package(). In this case make sure that "
+ "package has indeed been found and adjust CMAKE_MODULE_PATH to "
+ "contain the location where that package has installed "
+ "Find" << this->Name << ".cmake. This must be a location "
+ "provided by that package. This error in general means that "
+ "the buildsystem of this project is relying on a Find-module "
+ "without ensuring that it is actually available.\n";
+ }
+ }
+
+
+ this->Makefile->IssueMessage(
+ this->Required? cmake::FATAL_ERROR : cmake::WARNING, e.str());
+ if (this->Required)
+ {
+ cmSystemTools::SetFatalErrorOccured();
+ }
+
+ if (!aw.str().empty())
+ {
+ this->Makefile->IssueMessage(cmake::AUTHOR_WARNING,aw.str());
+ }
+ }
+
+ // Set a variable marking whether the package was found.
+ this->Makefile->AddDefinition(foundVar.c_str(), found? "1":"0");
+
+ // 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(), this->FileFound.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.
+ this->Makefile->AddDefinition
+ (upperDir.c_str(),
+ this->Makefile->GetDefinition(this->Variable.c_str()));
+ this->Makefile->AddDefinition
+ (upperFound.c_str(),
+ this->Makefile->GetDefinition(foundVar.c_str()));
+ }
+
+#ifdef CMAKE_BUILD_WITH_CMAKE
+ if(!(upperDir == this->Variable))
+ {
+ if(this->Compatibility_1_6)
+ {
+ // Listfiles may use the capitalized version of the name.
+ // Remove any previously added watch.
+ this->Makefile->GetVariableWatch()->RemoveWatch(
+ upperDir.c_str(),
+ cmFindPackageNeedBackwardsCompatibility
+ );
+ }
+ else
+ {
+ // Listfiles should not be using the capitalized version of the
+ // name. Add a watch to warn the user.
+ this->Makefile->GetVariableWatch()->AddWatch(
+ upperDir.c_str(),
+ cmFindPackageNeedBackwardsCompatibility
+ );
+ }
+ }
+#endif
+
+ std::string consideredConfigsVar = this->Name;
+ consideredConfigsVar += "_CONSIDERED_CONFIGS";
+ std::string consideredVersionsVar = this->Name;
+ consideredVersionsVar += "_CONSIDERED_VERSIONS";
+
+ std::string consideredConfigFiles;
+ std::string consideredVersions;
+
+ const char* sep = "";
+ for(std::vector<ConfigFileInfo>::size_type i=0;
+ i<this->ConsideredConfigs.size(); i++)
+ {
+ consideredConfigFiles += sep;
+ consideredVersions += sep;
+ consideredConfigFiles += this->ConsideredConfigs[i].filename;
+ consideredVersions += this->ConsideredConfigs[i].version;
+ sep = ";";
+ }
+
+ this->Makefile->AddDefinition(consideredConfigsVar.c_str(),
+ consideredConfigFiles.c_str());
+
+ this->Makefile->AddDefinition(consideredVersionsVar.c_str(),
+ consideredVersions.c_str());
+
+ return result;
+}
+
+//----------------------------------------------------------------------------
+bool cmFindPackageCommand::FindConfig()
+{
+ // Compute the set of search prefixes.
+ this->ComputePrefixes();
+
+ // Look for the project's configuration file.
+ bool found = false;
+
+ // Search for frameworks.
+ if(!found && (this->SearchFrameworkFirst || this->SearchFrameworkOnly))
+ {
+ found = this->FindFrameworkConfig();
+ }
+
+ // Search for apps.
+ if(!found && (this->SearchAppBundleFirst || this->SearchAppBundleOnly))
+ {
+ found = this->FindAppBundleConfig();
+ }
+
+ // Search prefixes.
+ if(!found && !(this->SearchFrameworkOnly || this->SearchAppBundleOnly))
+ {
+ found = this->FindPrefixedConfig();
+ }
+
+ // Search for frameworks.
+ if(!found && this->SearchFrameworkLast)
+ {
+ found = this->FindFrameworkConfig();
+ }
+
+ // 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 += ".";
+ // We force the value since we do not get here if it was already set.
+ this->Makefile->AddCacheDefinition(this->Variable.c_str(),
+ init.c_str(), help.c_str(),
+ cmCacheManager::PATH, true);
+ return found;
+}
+
+//----------------------------------------------------------------------------
+bool cmFindPackageCommand::FindPrefixedConfig()
+{
+ std::vector<std::string>& prefixes = this->SearchPaths;
+ for(std::vector<std::string>::const_iterator pi = prefixes.begin();
+ pi != prefixes.end(); ++pi)
+ {
+ if(this->SearchPrefix(*pi))
+ {
+ return true;
+ }
+ }
+ return false;
+}
+
+//----------------------------------------------------------------------------
+bool cmFindPackageCommand::FindFrameworkConfig()
+{
+ std::vector<std::string>& prefixes = this->SearchPaths;
+ for(std::vector<std::string>::const_iterator i = prefixes.begin();
+ i != prefixes.end(); ++i)
+ {
+ if(this->SearchFrameworkPrefix(*i))
+ {
+ return true;
+ }
+ }
+ return false;
+}
+
+//----------------------------------------------------------------------------
+bool cmFindPackageCommand::FindAppBundleConfig()
+{
+ std::vector<std::string>& prefixes = this->SearchPaths;
+ for(std::vector<std::string>::const_iterator i = prefixes.begin();
+ i != prefixes.end(); ++i)
+ {
+ if(this->SearchAppBundlePrefix(*i))
+ {
+ return true;
+ }
+ }
+ return false;
+}
+
+//----------------------------------------------------------------------------
+bool cmFindPackageCommand::ReadListFile(const char* f, PolicyScopeRule psr)
+{
+ if(this->Makefile->ReadListFile(this->Makefile->GetCurrentListFile(), f, 0,
+ !this->PolicyScope || psr == NoPolicyScope))
+ {
+ return true;
+ }
+ std::string e = "Error reading CMake code from \"";
+ e += f;
+ e += "\".";
+ this->SetError(e.c_str());
+ return false;
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::AppendToFoundProperty(bool found)
+{
+ std::vector<std::string> foundContents;
+ const char *foundProp =
+ this->Makefile->GetCMakeInstance()->GetProperty("PACKAGES_FOUND");
+ if (foundProp && *foundProp)
+ {
+ std::string tmp = foundProp;
+
+ cmSystemTools::ExpandListArgument(tmp, foundContents, false);
+ std::vector<std::string>::iterator nameIt = std::find(
+ foundContents.begin(), foundContents.end(), this->Name);
+ if(nameIt != foundContents.end())
+ {
+ foundContents.erase(nameIt);
+ }
+ }
+
+ std::vector<std::string> notFoundContents;
+ const char *notFoundProp =
+ this->Makefile->GetCMakeInstance()->GetProperty("PACKAGES_NOT_FOUND");
+ if (notFoundProp && *notFoundProp)
+ {
+ std::string tmp = notFoundProp;
+
+ cmSystemTools::ExpandListArgument(tmp, notFoundContents, false);
+ std::vector<std::string>::iterator nameIt = std::find(
+ notFoundContents.begin(), notFoundContents.end(), this->Name);
+ if(nameIt != notFoundContents.end())
+ {
+ notFoundContents.erase(nameIt);
+ }
+ }
+
+ if(found)
+ {
+ foundContents.push_back(this->Name);
+ }
+ else
+ {
+ notFoundContents.push_back(this->Name);
+ }
+
+
+ std::string tmp;
+ const char* sep ="";
+ for(size_t i=0; i<foundContents.size(); i++)
+ {
+ tmp += sep;
+ tmp += foundContents[i];
+ sep = ";";
+ }
+
+ this->Makefile->GetCMakeInstance()->SetProperty("PACKAGES_FOUND",
+ tmp.c_str());
+
+ tmp = "";
+ sep = "";
+ for(size_t i=0; i<notFoundContents.size(); i++)
+ {
+ tmp += sep;
+ tmp += notFoundContents[i];
+ sep = ";";
+ }
+ this->Makefile->GetCMakeInstance()->SetProperty("PACKAGES_NOT_FOUND",
+ tmp.c_str());
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::AppendSuccessInformation()
+{
+ std::string found = this->Name;
+ found += "_FOUND";
+ std::string upperFound = cmSystemTools::UpperCase(found);
+
+ const char* upperResult = this->Makefile->GetDefinition(upperFound.c_str());
+ const char* result = this->Makefile->GetDefinition(found.c_str());
+ bool packageFound = ((cmSystemTools::IsOn(result))
+ || (cmSystemTools::IsOn(upperResult)));
+
+ this->AppendToFoundProperty(packageFound);
+
+ // Record whether the find was quiet or not, so this can be used
+ // e.g. in FeatureSummary.cmake
+ std::string quietInfoPropName = "_CMAKE_";
+ quietInfoPropName += this->Name;
+ quietInfoPropName += "_QUIET";
+ this->Makefile->GetCMakeInstance()->SetProperty(quietInfoPropName.c_str(),
+ this->Quiet ? "TRUE" : "FALSE");
+
+ // set a global property to record the required version of this package
+ std::string versionInfoPropName = "_CMAKE_";
+ versionInfoPropName += this->Name;
+ versionInfoPropName += "_REQUIRED_VERSION";
+ std::string versionInfo;
+ if(!this->Version.empty())
+ {
+ versionInfo = this->VersionExact ? "==" : ">=";
+ versionInfo += " ";
+ versionInfo += this->Version;
+ }
+ this->Makefile->GetCMakeInstance()->SetProperty(versionInfoPropName.c_str(),
+ versionInfo.c_str());
+ if (this->Required)
+ {
+ std::string requiredInfoPropName = "_CMAKE_";
+ requiredInfoPropName += this->Name;
+ requiredInfoPropName += "_TYPE";
+ this->Makefile->GetCMakeInstance()->SetProperty(
+ requiredInfoPropName.c_str(), "REQUIRED");
+ }
+
+
+ // Restore original state of "_FIND_" variables we set.
+ this->RestoreFindDefinitions();
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::ComputePrefixes()
+{
+ this->AddPrefixesCMakeVariable();
+ this->AddPrefixesCMakeEnvironment();
+ this->AddPrefixesUserHints();
+ this->AddPrefixesSystemEnvironment();
+ this->AddPrefixesUserRegistry();
+ this->AddPrefixesBuilds();
+ this->AddPrefixesCMakeSystemVariable();
+ this->AddPrefixesSystemRegistry();
+ this->AddPrefixesUserGuess();
+ this->ComputeFinalPaths();
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::AddPrefixesCMakeEnvironment()
+{
+ 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(env, EnvPath);
+ }
+
+ this->AddEnvPath("CMAKE_PREFIX_PATH");
+ this->AddEnvPath("CMAKE_FRAMEWORK_PATH");
+ this->AddEnvPath("CMAKE_APPBUNDLE_PATH");
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::AddPrefixesCMakeVariable()
+{
+ if(!this->NoCMakePath && !this->NoDefaultPath)
+ {
+ this->AddCMakePath("CMAKE_PREFIX_PATH");
+ this->AddCMakePath("CMAKE_FRAMEWORK_PATH");
+ this->AddCMakePath("CMAKE_APPBUNDLE_PATH");
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::AddPrefixesSystemEnvironment()
+{
+ 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(cmSystemTools::GetFilenamePath(d), EnvPath);
+ }
+ else
+ {
+ this->AddPathInternal(d, EnvPath);
+ }
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::AddPrefixesUserRegistry()
+{
+ if(this->NoUserRegistry || this->NoDefaultPath)
+ {
+ return;
+ }
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+ this->LoadPackageRegistryWinUser();
+#elif defined(__HAIKU__)
+ BPath dir;
+ if (find_directory(B_USER_SETTINGS_DIRECTORY, &dir) == B_OK)
+ {
+ dir.Append("cmake/packages");
+ dir.Append(this->Name.c_str());
+ this->LoadPackageRegistryDir(dir.Path());
+ }
+#else
+ if(const char* home = cmSystemTools::GetEnv("HOME"))
+ {
+ std::string dir = home;
+ dir += "/.cmake/packages/";
+ dir += this->Name;
+ this->LoadPackageRegistryDir(dir);
+ }
+#endif
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::AddPrefixesSystemRegistry()
+{
+ if(this->NoSystemRegistry || this->NoDefaultPath)
+ {
+ return;
+ }
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+ this->LoadPackageRegistryWinSystem();
+#endif
+}
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+# include <windows.h>
+# undef GetCurrentDirectory
+ // http://msdn.microsoft.com/en-us/library/aa384253%28v=vs.85%29.aspx
+# if !defined(KEY_WOW64_32KEY)
+# define KEY_WOW64_32KEY 0x0200
+# endif
+# if !defined(KEY_WOW64_64KEY)
+# define KEY_WOW64_64KEY 0x0100
+# endif
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::LoadPackageRegistryWinUser()
+{
+ // HKEY_CURRENT_USER\\Software shares 32-bit and 64-bit views.
+ this->LoadPackageRegistryWin(true, 0);
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::LoadPackageRegistryWinSystem()
+{
+ // HKEY_LOCAL_MACHINE\\SOFTWARE has separate 32-bit and 64-bit views.
+ // Prefer the target platform view first.
+ if(this->Makefile->PlatformIs64Bit())
+ {
+ this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY);
+ this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY);
+ }
+ else
+ {
+ this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY);
+ this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY);
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::LoadPackageRegistryWin(bool user,
+ unsigned int view)
+{
+ std::string key = "Software\\Kitware\\CMake\\Packages\\";
+ key += this->Name;
+ std::set<cmStdString> bad;
+ HKEY hKey;
+ if(RegOpenKeyEx(user? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, key.c_str(),
+ 0, KEY_QUERY_VALUE|view, &hKey) == ERROR_SUCCESS)
+ {
+ DWORD valueType = REG_NONE;
+ char name[16384];
+ std::vector<char> data(512);
+ bool done = false;
+ DWORD index = 0;
+ while(!done)
+ {
+ DWORD nameSize = static_cast<DWORD>(sizeof(name));
+ DWORD dataSize = static_cast<DWORD>(data.size()-1);
+ switch(RegEnumValue(hKey, index, name, &nameSize,
+ 0, &valueType, (BYTE*)&data[0], &dataSize))
+ {
+ case ERROR_SUCCESS:
+ ++index;
+ if(valueType == REG_SZ)
+ {
+ data[dataSize] = 0;
+ cmsys_ios::stringstream ss(&data[0]);
+ if(!this->CheckPackageRegistryEntry(ss))
+ {
+ // The entry is invalid.
+ bad.insert(name);
+ }
+ }
+ break;
+ case ERROR_MORE_DATA:
+ data.resize(dataSize+1);
+ break;
+ case ERROR_NO_MORE_ITEMS: default: done = true; break;
+ }
+ }
+ RegCloseKey(hKey);
+ }
+
+ // Remove bad values if possible.
+ if(user && !bad.empty() &&
+ RegOpenKeyEx(HKEY_CURRENT_USER, key.c_str(),
+ 0, KEY_SET_VALUE|view, &hKey) == ERROR_SUCCESS)
+ {
+ for(std::set<cmStdString>::const_iterator vi = bad.begin();
+ vi != bad.end(); ++vi)
+ {
+ RegDeleteValue(hKey, vi->c_str());
+ }
+ RegCloseKey(hKey);
+ }
+}
+#else
+//----------------------------------------------------------------------------
+class cmFindPackageCommandHoldFile
+{
+ const char* File;
+public:
+ cmFindPackageCommandHoldFile(const char* f): File(f) {}
+ ~cmFindPackageCommandHoldFile()
+ { if(this->File) { cmSystemTools::RemoveFile(this->File); } }
+ void Release() { this->File = 0; }
+};
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::LoadPackageRegistryDir(std::string const& dir)
+{
+ cmsys::Directory files;
+ if(!files.Load(dir.c_str()))
+ {
+ return;
+ }
+
+ std::string fname;
+ for(unsigned long i=0; i < files.GetNumberOfFiles(); ++i)
+ {
+ fname = dir;
+ fname += "/";
+ fname += files.GetFile(i);
+
+ if(!cmSystemTools::FileIsDirectory(fname.c_str()))
+ {
+ // Hold this file hostage until it behaves.
+ cmFindPackageCommandHoldFile holdFile(fname.c_str());
+
+ // Load the file.
+ std::ifstream fin(fname.c_str(), std::ios::in | cmsys_ios_binary);
+ if(fin && this->CheckPackageRegistryEntry(fin))
+ {
+ // The file references an existing package, so release it.
+ holdFile.Release();
+ }
+ }
+ }
+
+ // TODO: Wipe out the directory if it is empty.
+}
+#endif
+
+//----------------------------------------------------------------------------
+bool cmFindPackageCommand::CheckPackageRegistryEntry(std::istream& is)
+{
+ // Parse the content of one package registry entry.
+ std::string fname;
+ if(cmSystemTools::GetLineFromStream(is, fname) &&
+ cmSystemTools::FileIsFullPath(fname.c_str()))
+ {
+ // The first line in the stream is the full path to a file or
+ // directory containing the package.
+ if(cmSystemTools::FileExists(fname.c_str()))
+ {
+ // The path exists. Look for the package here.
+ if(!cmSystemTools::FileIsDirectory(fname.c_str()))
+ {
+ fname = cmSystemTools::GetFilenamePath(fname);
+ }
+ this->AddPathInternal(fname, FullPath);
+ return true;
+ }
+ else
+ {
+ // The path does not exist. Assume the stream content is
+ // associated with an old package that no longer exists, and
+ // delete it to keep the package registry clean.
+ return false;
+ }
+ }
+ else
+ {
+ // The first line in the stream is not the full path to a file or
+ // directory. Assume the stream content was created by a future
+ // version of CMake that uses a different format, and leave it.
+ return true;
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::AddPrefixesBuilds()
+{
+ 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.c_str()))
+ {
+ this->AddPathInternal(f, FullPath);
+ }
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::AddPrefixesCMakeSystemVariable()
+{
+ if(!this->NoCMakeSystemPath && !this->NoDefaultPath)
+ {
+ this->AddCMakePath("CMAKE_SYSTEM_PREFIX_PATH");
+ this->AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
+ this->AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH");
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::AddPrefixesUserGuess()
+{
+ // Add guesses specified by the caller.
+ this->AddPathsInternal(this->UserPaths, CMakePath);
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::AddPrefixesUserHints()
+{
+ // Add hints specified by the caller.
+ this->AddPathsInternal(this->UserHints, CMakePath);
+}
+
+//----------------------------------------------------------------------------
+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))
+ {
+ // Remove duplicate slashes.
+ cmSystemTools::ConvertToUnixSlashes(this->FileFound);
+ return true;
+ }
+ return false;
+}
+
+//----------------------------------------------------------------------------
+bool cmFindPackageCommand::FindConfigFile(std::string const& dir,
+ std::string& file)
+{
+ if (this->IgnoredPaths.count(dir))
+ {
+ return false;
+ }
+
+ 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) &&
+ this->CheckVersion(file))
+ {
+ return true;
+ }
+ }
+ return false;
+}
+
+//----------------------------------------------------------------------------
+bool cmFindPackageCommand::CheckVersion(std::string const& config_file)
+{
+ bool result = false; // by default, assume the version is not ok.
+ bool haveResult = false;
+ std::string version = "unknown";
+
+ // Get the filename without the .cmake extension.
+ std::string::size_type pos = config_file.rfind('.');
+ std::string version_file_base = config_file.substr(0, pos);
+
+ // Look for foo-config-version.cmake
+ std::string version_file = version_file_base;
+ version_file += "-version.cmake";
+ if ((haveResult == false)
+ && (cmSystemTools::FileExists(version_file.c_str(), true)))
+ {
+ result = this->CheckVersionFile(version_file, version);
+ haveResult = true;
+ }
+
+ // Look for fooConfigVersion.cmake
+ version_file = version_file_base;
+ version_file += "Version.cmake";
+ if ((haveResult == false)
+ && (cmSystemTools::FileExists(version_file.c_str(), true)))
+ {
+ result = this->CheckVersionFile(version_file, version);
+ haveResult = true;
+ }
+
+
+ // If no version was requested a versionless package is acceptable.
+ if ((haveResult == false) && (this->Version.empty()))
+ {
+ result = true;
+ haveResult = true;
+ }
+
+ ConfigFileInfo configFileInfo;
+ configFileInfo.filename = config_file;
+ configFileInfo.version = version;
+ this->ConsideredConfigs.push_back(configFileInfo);
+
+ return result;
+}
+
+//----------------------------------------------------------------------------
+bool cmFindPackageCommand::CheckVersionFile(std::string const& version_file,
+ std::string& result_version)
+{
+ // The version file will be loaded in an isolated scope.
+ cmMakefile::ScopePushPop varScope(this->Makefile);
+ cmMakefile::PolicyPushPop polScope(this->Makefile);
+ static_cast<void>(varScope);
+ static_cast<void>(polScope);
+
+ // Clear the output variables.
+ this->Makefile->RemoveDefinition("PACKAGE_VERSION");
+ this->Makefile->RemoveDefinition("PACKAGE_VERSION_UNSUITABLE");
+ this->Makefile->RemoveDefinition("PACKAGE_VERSION_COMPATIBLE");
+ this->Makefile->RemoveDefinition("PACKAGE_VERSION_EXACT");
+
+ // Set the input variables.
+ this->Makefile->AddDefinition("PACKAGE_FIND_NAME", this->Name.c_str());
+ this->Makefile->AddDefinition("PACKAGE_FIND_VERSION",
+ this->Version.c_str());
+ char buf[64];
+ sprintf(buf, "%u", this->VersionMajor);
+ this->Makefile->AddDefinition("PACKAGE_FIND_VERSION_MAJOR", buf);
+ sprintf(buf, "%u", this->VersionMinor);
+ this->Makefile->AddDefinition("PACKAGE_FIND_VERSION_MINOR", buf);
+ sprintf(buf, "%u", this->VersionPatch);
+ this->Makefile->AddDefinition("PACKAGE_FIND_VERSION_PATCH", buf);
+ sprintf(buf, "%u", this->VersionTweak);
+ this->Makefile->AddDefinition("PACKAGE_FIND_VERSION_TWEAK", buf);
+ sprintf(buf, "%u", this->VersionCount);
+ this->Makefile->AddDefinition("PACKAGE_FIND_VERSION_COUNT", buf);
+
+ // Load the version check file. Pass NoPolicyScope because we do
+ // our own policy push/pop independent of CMP0011.
+ bool suitable = false;
+ if(this->ReadListFile(version_file.c_str(), NoPolicyScope))
+ {
+ // Check the output variables.
+ bool okay = this->Makefile->IsOn("PACKAGE_VERSION_EXACT");
+ bool unsuitable = this->Makefile->IsOn("PACKAGE_VERSION_UNSUITABLE");
+ if(!okay && !this->VersionExact)
+ {
+ okay = this->Makefile->IsOn("PACKAGE_VERSION_COMPATIBLE");
+ }
+
+ // The package is suitable if the version is okay and not
+ // explicitly unsuitable.
+ suitable = !unsuitable && (okay || this->Version.empty());
+ if(suitable)
+ {
+ // Get the version found.
+ this->VersionFound =
+ this->Makefile->GetSafeDefinition("PACKAGE_VERSION");
+
+ // Try to parse the version number and store the results that were
+ // successfully parsed.
+ unsigned int parsed_major;
+ unsigned int parsed_minor;
+ unsigned int parsed_patch;
+ unsigned int parsed_tweak;
+ this->VersionFoundCount =
+ sscanf(this->VersionFound.c_str(), "%u.%u.%u.%u",
+ &parsed_major, &parsed_minor,
+ &parsed_patch, &parsed_tweak);
+ switch(this->VersionFoundCount)
+ {
+ case 4: this->VersionFoundTweak = parsed_tweak; // no break!
+ case 3: this->VersionFoundPatch = parsed_patch; // no break!
+ case 2: this->VersionFoundMinor = parsed_minor; // no break!
+ case 1: this->VersionFoundMajor = parsed_major; // no break!
+ default: break;
+ }
+ }
+ }
+
+ result_version = this->Makefile->GetSafeDefinition("PACKAGE_VERSION");
+ if (result_version.empty())
+ {
+ result_version = "unknown";
+ }
+
+ // Succeed if the version is suitable.
+ return suitable;
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::StoreVersionFound()
+{
+ // Store the whole version string.
+ std::string ver = this->Name;
+ ver += "_VERSION";
+ if(this->VersionFound.empty())
+ {
+ this->Makefile->RemoveDefinition(ver.c_str());
+ }
+ else
+ {
+ this->Makefile->AddDefinition(ver.c_str(), this->VersionFound.c_str());
+ }
+
+ // Store the version components.
+ char buf[64];
+ sprintf(buf, "%u", this->VersionFoundMajor);
+ this->Makefile->AddDefinition((ver+"_MAJOR").c_str(), buf);
+ sprintf(buf, "%u", this->VersionFoundMinor);
+ this->Makefile->AddDefinition((ver+"_MINOR").c_str(), buf);
+ sprintf(buf, "%u", this->VersionFoundPatch);
+ this->Makefile->AddDefinition((ver+"_PATCH").c_str(), buf);
+ sprintf(buf, "%u", this->VersionFoundTweak);
+ this->Makefile->AddDefinition((ver+"_TWEAK").c_str(), buf);
+ sprintf(buf, "%u", this->VersionFoundCount);
+ this->Makefile->AddDefinition((ver+"_COUNT").c_str(), buf);
+}
+
+//----------------------------------------------------------------------------
+#include <cmsys/Glob.hxx>
+#include <cmsys/String.h>
+#include <cmsys/auto_ptr.hxx>
+
+class cmFileList;
+class cmFileListGeneratorBase
+{
+public:
+ virtual ~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) {}
+ virtual ~cmFileList() {}
+ 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(std::vector<std::string> const& v):
+ cmFileListGeneratorBase(), Vector(v) {}
+ cmFileListGeneratorEnumerate(cmFileListGeneratorEnumerate const& r):
+ cmFileListGeneratorBase(), Vector(r.Vector) {}
+private:
+ std::vector<std::string> const& 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/(Foo|foo|FOO).*/
+ {
+ cmFindPackageFileList lister(this);
+ lister
+ / cmFileListGeneratorFixed(prefix)
+ / cmFileListGeneratorProject(this->Names);
+ if(lister.Search())
+ {
+ return true;
+ }
+ }
+
+ // PREFIX/(Foo|foo|FOO).*/(cmake|CMake)/
+ {
+ cmFindPackageFileList lister(this);
+ lister
+ / cmFileListGeneratorFixed(prefix)
+ / cmFileListGeneratorProject(this->Names)
+ / cmFileListGeneratorCaseInsensitive("cmake");
+ if(lister.Search())
+ {
+ return true;
+ }
+ }
+
+ // Construct list of common install locations (lib and share).
+ std::vector<std::string> common;
+ if(!this->LibraryArchitecture.empty())
+ {
+ common.push_back("lib/"+this->LibraryArchitecture);
+ }
+ if(this->UseLib64Paths)
+ {
+ common.push_back("lib64");
+ }
+ common.push_back("lib");
+ common.push_back("share");
+
+ // PREFIX/(lib/ARCH|lib|share)/cmake/(Foo|foo|FOO).*/
+ {
+ cmFindPackageFileList lister(this);
+ lister
+ / cmFileListGeneratorFixed(prefix)
+ / cmFileListGeneratorEnumerate(common)
+ / cmFileListGeneratorFixed("cmake")
+ / cmFileListGeneratorProject(this->Names);
+ if(lister.Search())
+ {
+ return true;
+ }
+ }
+
+ // PREFIX/(lib/ARCH|lib|share)/(Foo|foo|FOO).*/
+ {
+ cmFindPackageFileList lister(this);
+ lister
+ / cmFileListGeneratorFixed(prefix)
+ / cmFileListGeneratorEnumerate(common)
+ / cmFileListGeneratorProject(this->Names);
+ if(lister.Search())
+ {
+ return true;
+ }
+ }
+
+ // PREFIX/(lib/ARCH|lib|share)/(Foo|foo|FOO).*/(cmake|CMake)/
+ {
+ cmFindPackageFileList lister(this);
+ lister
+ / cmFileListGeneratorFixed(prefix)
+ / cmFileListGeneratorEnumerate(common)
+ / 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: Debug cmsys::Glob double slash problem.