-sync FindPackageHandleStandardArgs.cmake with the version from cmake master, in order to stay compatible with future cmake releases.

Our FindPackageHandleStandardArgs.cmake had automatic check for the version number by guessing
the name of the variable which contains the version number. This didn't make it into cmake, but
instead an extendible version where you can specify what you want.

FindEigen2.cmake is already converted, it looks like this:

find_package_handle_standard_args(Eigen2 REQUIRED_VARS EIGEN2_INCLUDE_DIR
                                         VERSION_VAR EIGEN2_VERSION)

Additionally a FAIL_MESSAGE can be specified. VERSION_VAR is optional.

This must be merged in the 4.5. branch if we don't find any issues.


Alex

CCMAIL: kde-buildsystem@kde.org


svn path=/trunk/KDE/kdelibs/; revision=1167973

4 files changed, 282 insertions, 112 deletions

diff --git a/modules/CMakeLists.txt b/modules/CMakeLists.txt
index 637f8cab..03e4d15d 100644
--- a/modules/CMakeLists.txt
+++ b/modules/CMakeLists.txt
@@ -10,13 +10,10 @@ set(cmakeFilesDontInstall
                FindPolkitQt.cmake
                FindPolkitQt-1.cmake)
 
-# remove once we depend on a newer cmake version:
-# FindPackageHandleStandardArgs (2.8.2)
-
 # Explicitely list all files which will be installed.
 # We don't use a GLOB anymore so we can have also cmake files here
 # which are used inside kdelibs, but which don't have to be installed (and
-# so become part of the public interface of kdelibs which has to be kept 
+# so become part of the public interface of kdelibs which has to be kept
 # compatible).
 set(cmakeFiles CheckCXXSourceCompiles.cmake
                CheckCXXSourceRuns.cmake
@@ -101,6 +98,7 @@ set(cmakeFiles CheckCXXSourceCompiles.cmake
                Qt4Macros.cmake
                Qt4ConfigDependentSettings.cmake
                FindPackageHandleStandardArgs.cmake
+               CMakeParseArguments.cmake  # used by FindPackageHandleStandardArgs.cmake, will be in CMake 2.8.3
                FindPythonLibrary.cmake
                FindQCA2.cmake
                FindQImageBlitz.cmake
@@ -150,11 +148,11 @@ set(cmakeFiles CheckCXXSourceCompiles.cmake
                create_exe_symlink.cmake
                kde4_exec_via_sh.cmake
                kde4uic.cmake
-               cmake-modules-styleguide.txt 
-               kde4init_dummy.cpp.in 
-               kde4init_win32lib_dummy.cpp.in 
-               kde4_cmake_uninstall.cmake.in 
-               kde4automoc.files.in 
+               cmake-modules-styleguide.txt
+               kde4init_dummy.cpp.in
+               kde4init_win32lib_dummy.cpp.in
+               kde4_cmake_uninstall.cmake.in
+               kde4automoc.files.in
                BasicFindPackageVersion.cmake.in
                FindLibPython.py
                FindPyKDE4.py
@@ -170,7 +168,7 @@ endif (KDE4_ENABLE_UAC_MANIFEST)
 install(FILES ${cmakeFiles}
         DESTINATION ${module_install_dir} )
 
-         
+
 # the files listed here will be removed by remove_obsoleted_cmake_files.cmake, Alex
 #set(FILES_TO_REMOVE
 #)
diff --git a/modules/CMakeParseArguments.cmake b/modules/CMakeParseArguments.cmake
new file mode 100644
index 00000000..7ce4c49a
--- /dev/null
+++ b/modules/CMakeParseArguments.cmake
@@ -0,0 +1,138 @@
+# CMAKE_PARSE_ARGUMENTS(<prefix> <options> <one_value_keywords> <multi_value_keywords> args...)
+#
+# CMAKE_PARSE_ARGUMENTS() is intended to be used in macros or functions for
+# parsing the arguments given to that macro or function.
+# It processes the arguments and defines a set of variables which hold the
+# values of the respective options.
+#
+# The <options> argument contains all options for the respective macro,
+# i.e. keywords which can be used when calling the macro without any value
+# following, like e.g. the OPTIONAL keyword of the install() command.
+#
+# The <one_value_keywords> argument contains all keywords for this macro
+# which are followed by one value, like e.g. DESTINATION keyword of the
+# install() command.
+#
+# The <multi_value_keywords> argument contains all keywords for this macro
+# which can be followed by more than one value, like e.g. the TARGETS or
+# FILES keywords of the install() command.
+#
+# When done, CMAKE_PARSE_ARGUMENTS() will have defined for each of the
+# keywords listed in <options>, <one_value_keywords> and
+# <multi_value_keywords> a variable composed of the given <prefix>
+# followed by "_" and the name of the respective keyword.
+# These variables will then hold the respective value from the argument list.
+# For the <options> keywords this will be TRUE or FALSE.
+#
+# All remaining arguments are collected in a variable
+# <prefix>_UNPARSED_ARGUMENTS, this can be checked afterwards to see whether
+# your macro was called with unrecognized parameters.
+#
+# As an example here a my_install() macro, which takes similar arguments as the
+# real install() command:
+#
+#   function(MY_INSTALL)
+#     set(options OPTIONAL FAST)
+#     set(oneValueArgs DESTINATION RENAME)
+#     set(multiValueArgs TARGETS CONFIGURATIONS)
+#     cmake_parse_arguments(MY_INSTALL "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
+#     ...
+#
+# Assume my_install() has been called like this:
+#   my_install(TARGETS foo bar DESTINATION bin OPTIONAL blub)
+#
+# After the cmake_parse_arguments() call the macro will have set the following
+# variables:
+#   MY_INSTALL_OPTIONAL = TRUE
+#   MY_INSTALL_FAST = FALSE (this option was not used when calling my_install()
+#   MY_INSTALL_DESTINATION = "bin"
+#   MY_INSTALL_RENAME = "" (was not used)
+#   MY_INSTALL_TARGETS = "foo;bar"
+#   MY_INSTALL_CONFIGURATIONS = "" (was not used)
+#   MY_INSTALL_UNPARSED_ARGUMENTS = "blub" (no value expected after "OPTIONAL"
+#
+# You can the continue and process these variables.
+#
+# Keywords terminate lists of values, e.g. if directly after a one_value_keyword
+# another recognized keyword follows, this is interpreted as the beginning of
+# the new option.
+# E.g. my_install(TARGETS foo DESTINATION OPTIONAL) would result in
+# MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION would
+# be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefor.
+
+#=============================================================================
+# Copyright 2010 Alexander Neundorf <neundorf@kde.org>
+#
+# 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.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+
+if(__CMAKE_PARSE_ARGUMENTS_INCLUDED)
+  return()
+endif()
+set(__CMAKE_PARSE_ARGUMENTS_INCLUDED TRUE)
+
+
+function(CMAKE_PARSE_ARGUMENTS prefix _optionNames _singleArgNames _multiArgNames)
+  # first set all result variables to empty/FALSE
+  foreach(arg_name ${_singleArgNames} ${_multiArgNames})
+    set(${prefix}_${arg_name})
+  endforeach(arg_name)
+
+  foreach(option ${_optionNames})
+    set(${prefix}_${option} FALSE)
+  endforeach(option)
+
+  set(${prefix}_UNPARSED_ARGUMENTS)
+
+  set(insideValues FALSE)
+  set(currentArgName)
+
+  # now iterate over all arguments and fill the result variables
+  foreach(currentArg ${ARGN})
+    list(FIND _optionNames "${currentArg}" optionIndex)  # ... then this marks the end of the arguments belonging to this keyword
+    list(FIND _singleArgNames "${currentArg}" singleArgIndex)  # ... then this marks the end of the arguments belonging to this keyword
+    list(FIND _multiArgNames "${currentArg}" multiArgIndex)  # ... then this marks the end of the arguments belonging to this keyword
+
+    if(${optionIndex} EQUAL -1  AND  ${singleArgIndex} EQUAL -1  AND  ${multiArgIndex} EQUAL -1)
+      if(insideValues)
+        if("${insideValues}" STREQUAL "SINGLE")
+          set(${prefix}_${currentArgName} ${currentArg})
+          set(insideValues FALSE)
+        elseif("${insideValues}" STREQUAL "MULTI")
+          list(APPEND ${prefix}_${currentArgName} ${currentArg})
+        endif()
+      else(insideValues)
+        list(APPEND ${prefix}_UNPARSED_ARGUMENTS ${currentArg})
+      endif(insideValues)
+    else()
+      if(NOT ${optionIndex} EQUAL -1)
+        set(${prefix}_${currentArg} TRUE)
+        set(insideValues FALSE)
+      elseif(NOT ${singleArgIndex} EQUAL -1)
+        set(currentArgName ${currentArg})
+        set(${prefix}_${currentArgName})
+        set(insideValues "SINGLE")
+      elseif(NOT ${multiArgIndex} EQUAL -1)
+        set(currentArgName ${currentArg})
+        set(${prefix}_${currentArgName})
+        set(insideValues "MULTI")
+      endif()
+    endif()
+
+  endforeach(currentArg)
+
+  # propagate the result variables to the caller:
+  foreach(arg_name ${_singleArgNames} ${_multiArgNames} ${_optionNames})
+    set(${prefix}_${arg_name}  ${${prefix}_${arg_name}} PARENT_SCOPE)
+  endforeach(arg_name)
+  set(${prefix}_UNPARSED_ARGUMENTS ${${prefix}_UNPARSED_ARGUMENTS} PARENT_SCOPE)
+
+endfunction(CMAKE_PARSE_ARGUMENTS _options _singleArgs _multiArgs)
diff --git a/modules/FindEigen2.cmake b/modules/FindEigen2.cmake
index 0e86aaf2..83949e99 100644
--- a/modules/FindEigen2.cmake
+++ b/modules/FindEigen2.cmake
@@ -15,20 +15,14 @@
 # Redistribution and use is allowed according to the terms of the BSD license.
 
 if(NOT Eigen2_FIND_VERSION)
-  if(NOT Eigen2_FIND_VERSION_MAJOR)
-    set(Eigen2_FIND_VERSION_MAJOR 2)
-  endif(NOT Eigen2_FIND_VERSION_MAJOR)
-  if(NOT Eigen2_FIND_VERSION_MINOR)
-    set(Eigen2_FIND_VERSION_MINOR 0)
-  endif(NOT Eigen2_FIND_VERSION_MINOR)
-  if(NOT Eigen2_FIND_VERSION_PATCH)
-    set(Eigen2_FIND_VERSION_PATCH 0)
-  endif(NOT Eigen2_FIND_VERSION_PATCH)
+  set(Eigen2_FIND_VERSION_MAJOR 2)
+  set(Eigen2_FIND_VERSION_MINOR 0)
+  set(Eigen2_FIND_VERSION_PATCH 0)
 
   set(Eigen2_FIND_VERSION "${Eigen2_FIND_VERSION_MAJOR}.${Eigen2_FIND_VERSION_MINOR}.${Eigen2_FIND_VERSION_PATCH}")
 endif(NOT Eigen2_FIND_VERSION)
 
-macro(_eigen2_check_version)
+macro(_eigen2_get_version)
   file(READ "${EIGEN2_INCLUDE_DIR}/Eigen/src/Core/util/Macros.h" _eigen2_version_header LIMIT 5000 OFFSET 1000)
 
   string(REGEX MATCH "define *EIGEN_WORLD_VERSION ([0-9]*)" _eigen2_world_version_match "${_eigen2_version_header}")
@@ -39,26 +33,7 @@ macro(_eigen2_check_version)
   set(EIGEN2_MINOR_VERSION "${CMAKE_MATCH_1}")
 
   set(EIGEN2_VERSION ${EIGEN2_WORLD_VERSION}.${EIGEN2_MAJOR_VERSION}.${EIGEN2_MINOR_VERSION})
-  if(${EIGEN2_VERSION} VERSION_LESS ${Eigen2_FIND_VERSION})
-    set(EIGEN2_VERSION_OK FALSE)
-  else(${EIGEN2_VERSION} VERSION_LESS ${Eigen2_FIND_VERSION})
-    set(EIGEN2_VERSION_OK TRUE)
-  endif(${EIGEN2_VERSION} VERSION_LESS ${Eigen2_FIND_VERSION})
-
-  if(NOT EIGEN2_VERSION_OK)
-  
-    message(STATUS "Eigen2 version ${EIGEN2_VERSION} found in ${EIGEN2_INCLUDE_DIR}, "
-                   "but at least version ${Eigen2_FIND_VERSION} is required")
-  endif(NOT EIGEN2_VERSION_OK)
-endmacro(_eigen2_check_version)
-
-if (EIGEN2_INCLUDE_DIR)
-
-  # in cache already
-  _eigen2_check_version()
-  set(EIGEN2_FOUND ${EIGEN2_VERSION_OK})
-
-else (EIGEN2_INCLUDE_DIR)
+endmacro(_eigen2_get_version)
 
 find_path(EIGEN2_INCLUDE_DIR NAMES Eigen/Core
      PATHS
@@ -68,13 +43,13 @@ find_path(EIGEN2_INCLUDE_DIR NAMES Eigen/Core
    )
 
 if(EIGEN2_INCLUDE_DIR)
-  _eigen2_check_version()
+  _eigen2_get_version()
 endif(EIGEN2_INCLUDE_DIR)
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(Eigen2 DEFAULT_MSG EIGEN2_INCLUDE_DIR EIGEN2_VERSION_OK)
+find_package_handle_standard_args(Eigen2 REQUIRED_VARS EIGEN2_INCLUDE_DIR
+                                         VERSION_VAR EIGEN2_VERSION)
 
 mark_as_advanced(EIGEN2_INCLUDE_DIR)
 
-endif(EIGEN2_INCLUDE_DIR)
 
diff --git a/modules/FindPackageHandleStandardArgs.cmake b/modules/FindPackageHandleStandardArgs.cmake
index fe4345c7..c698480b 100644
--- a/modules/FindPackageHandleStandardArgs.cmake
+++ b/modules/FindPackageHandleStandardArgs.cmake
@@ -1,24 +1,58 @@
-# FIND_PACKAGE_HANDLE_STANDARD_ARGS(NAME (DEFAULT_MSG|"Custom failure message") VAR1 ... )
-#    This macro is intended to be used in FindXXX.cmake modules files.
-#    It handles the REQUIRED and QUIET argument to FIND_PACKAGE() and
-#    it also sets the <UPPERCASED_NAME>_FOUND variable.
-#    The package is considered found if all variables listed are TRUE.
-#    The version-argument of FIND_PACKAGE() is also handled. 
-#    For checking whether the version is ok, this macro compares the 
-#    variable <UPPERCASED_NAME>_VERSION with the specified version.
-#    Example:
+# FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name> ... )
 #
-#    FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibXml2 DEFAULT_MSG LIBXML2_LIBRARIES LIBXML2_INCLUDE_DIR)
+# This function is intended to be used in FindXXX.cmake modules files.
+# It handles the REQUIRED, QUIET and version-related arguments to FIND_PACKAGE().
+# It also sets the <UPPERCASED_NAME>_FOUND variable.
+# The package is considered found if all variables <var1>... listed contain
+# valid results, e.g. valid filepaths.
 #
-#    LibXml2 is considered to be found, if both LIBXML2_LIBRARIES and 
-#    LIBXML2_INCLUDE_DIR are valid. Then also LIBXML2_FOUND is set to TRUE.
-#    If it is not found and REQUIRED was used, it fails with FATAL_ERROR, 
-#    independent whether QUIET was used or not.
-#    If it is found, the location is reported using the VAR1 argument, so 
-#    here a message "Found LibXml2: /usr/lib/libxml2.so" will be printed out.
-#    If the second argument is DEFAULT_MSG, the message in the failure case will 
-#    be "Could NOT find LibXml2", if you don't like this message you can specify
-#    your own custom failure message there.
+# There are two modes of this function. The first argument in both modes is
+# the name of the Find-module where it is called (in original casing).
+#
+# The first simple mode looks like this:
+#    FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name> (DEFAULT_MSG|"Custom failure message") <var1>...<varN> )
+# If the variables <var1> to <varN> are all valid, then <UPPERCASED_NAME>_FOUND
+# will be set to TRUE.
+# If DEFAULT_MSG is given as second argument, then the function will generate
+# itself useful success and error messages. You can also supply a custom error message
+# for the failure case. This is not recommended.
+#
+# The second mode is more powerful and also supports version checking:
+#    FIND_PACKAGE_HANDLE_STANDARD_ARGS(NAME [REQUIRED_VARS <var1>...<varN>]
+#                                           [VERSION_VAR   <versionvar>
+#                                           [FAIL_MESSAGE "Custom failure message"] )
+#
+# As above, if <var1> through <varN> are all valid, <UPPERCASED_NAME>_FOUND
+# will be set to TRUE.
+# Via FAIL_MESSAGE a custom failure message can be specified, if this is not
+# used, the default message will be displayed.
+# Following VERSION_VAR the name of the variable can be specified which holds
+# the version of the package which has been found. If this is done, this version
+# will be checked against the (potentially) specified required version used
+# in the find_package() call. The EXACT keyword is also handled. The default
+# messages include information about the required version and the version
+# which has been actually found, both if the version is ok or not.
+#
+# Example for mode 1:
+#
+#    FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibXml2  DEFAULT_MSG  LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR)
+#
+# LibXml2 is considered to be found, if both LIBXML2_LIBRARY and
+# LIBXML2_INCLUDE_DIR are valid. Then also LIBXML2_FOUND is set to TRUE.
+# If it is not found and REQUIRED was used, it fails with FATAL_ERROR,
+# independent whether QUIET was used or not.
+# If it is found, success will be reported, including the content of <var1>.
+# On repeated Cmake runs, the same message won't be printed again.
+#
+# Example for mode 2:
+#
+#    FIND_PACKAGE_HANDLE_STANDARD_ARGS(BISON  REQUIRED_VARS BISON_EXECUTABLE
+#                                             VERSION_VAR BISON_VERSION)
+# In this case, BISON is considered to be found if the variable(s) listed
+# after REQUIRED_VAR are all valid, i.e. BISON_EXECUTABLE in this case.
+# Also the version of BISON will be checked by using the version contained
+# in BISON_VERSION.
+# Since no FAIL_MESSAGE is given, the default messages will be printed.
 
 #=============================================================================
 # Copyright 2007-2009 Kitware, Inc.
@@ -30,17 +64,51 @@
 # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 # See the License for more information.
 #=============================================================================
-# (To distributed this file outside of CMake, substitute the full
+# (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 
 INCLUDE(FindPackageMessage)
-FUNCTION(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FAIL_MSG _VAR1 )
+INCLUDE(CMakeParseArguments)
+
+
+FUNCTION(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG _VAR1)
+
+# set up the arguments for CMAKE_PARSE_ARGUMENTS and check whether we are in
+# new extended or in the "old" mode:
+  SET(options) # none
+  SET(oneValueArgs FAIL_MESSAGE VERSION_VAR)
+  SET(multiValueArgs REQUIRED_VARS)
+  SET(_KEYWORDS_FOR_EXTENDED_MODE  ${options} ${oneValueArgs} ${multiValueArgs} )
+  LIST(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX)
+
+  IF(${INDEX} EQUAL -1)
+    SET(FPHSA_FAIL_MESSAGE ${_FIRST_ARG})
+    SET(FPHSA_REQUIRED_VARS ${_VAR1} ${ARGN})
+    SET(FPHSA_VERSION_VAR)
+  ELSE(${INDEX} EQUAL -1)
 
-  IF("${_FAIL_MSG}" STREQUAL "DEFAULT_MSG")
-    SET(_FAIL_MESSAGE "Could NOT find ${_NAME}")
-  ELSE("${_FAIL_MSG}" STREQUAL "DEFAULT_MSG")
-    SET(_FAIL_MESSAGE "${_FAIL_MSG}")
-  ENDIF("${_FAIL_MSG}" STREQUAL "DEFAULT_MSG")
+    CMAKE_PARSE_ARGUMENTS(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}"  ${_FIRST_ARG} ${_VAR1} ${ARGN})
+
+    IF(FPHSA_UNPARSED_ARGUMENTS)
+      MESSAGE(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"")
+    ENDIF(FPHSA_UNPARSED_ARGUMENTS)
+
+    IF(NOT FPHSA_FAIL_MESSAGE)
+      SET(FPHSA_FAIL_MESSAGE  "DEFAULT_MSG")
+    ENDIF(NOT FPHSA_FAIL_MESSAGE)
+  ENDIF(${INDEX} EQUAL -1)
+
+# now that we collected all arguments, process them
+
+  IF("${FPHSA_FAIL_MESSAGE}" STREQUAL "DEFAULT_MSG")
+    SET(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}")
+  ENDIF("${FPHSA_FAIL_MESSAGE}" STREQUAL "DEFAULT_MSG")
+
+  IF(NOT FPHSA_REQUIRED_VARS)
+    MESSAGE(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()")
+  ENDIF(NOT FPHSA_REQUIRED_VARS)
+
+  LIST(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR)
 
   STRING(TOUPPER ${_NAME} _NAME_UPPER)
 
@@ -49,15 +117,8 @@ FUNCTION(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FAIL_MSG _VAR1 )
   SET(MISSING_VARS "")
   SET(DETAILS "")
   SET(${_NAME_UPPER}_FOUND TRUE)
-  IF(NOT ${_VAR1})
-    SET(${_NAME_UPPER}_FOUND FALSE)
-    SET(MISSING_VARS " ${_VAR1}")
-  ELSE(NOT ${_VAR1})
-    SET(DETAILS "${DETAILS}[${${_VAR1}}]")
-  ENDIF(NOT ${_VAR1})
-
   # check if all passed variables are valid
-  FOREACH(_CURRENT_VAR ${ARGN})
+  FOREACH(_CURRENT_VAR ${FPHSA_REQUIRED_VARS})
     IF(NOT ${_CURRENT_VAR})
       SET(${_NAME_UPPER}_FOUND FALSE)
       SET(MISSING_VARS "${MISSING_VARS} ${_CURRENT_VAR}")
@@ -66,6 +127,7 @@ FUNCTION(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FAIL_MSG _VAR1 )
     ENDIF(NOT ${_CURRENT_VAR})
   ENDFOREACH(_CURRENT_VAR)
 
+
   # version handling:
   SET(VERSION_MSG "")
   SET(VERSION_OK TRUE)
@@ -73,36 +135,33 @@ FUNCTION(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FAIL_MSG _VAR1 )
 
     # if the package was found, check for the version using <NAME>_FIND_VERSION
     IF (${_NAME_UPPER}_FOUND)
-      IF(${_NAME_UPPER}_VERSION)
-        SET(VERSION ${${_NAME_UPPER}_VERSION})
-      ELSEIF(${_NAME}_VERSION)
-        SET(VERSION ${${_NAME}_VERSION})
-      ENDIF(${_NAME_UPPER}_VERSION)
-      
-      IF(VERSION)  #hmm what do we do if the module in question doesn't set FOO_VERSION but something else ?... Ignore it for now
-
-      IF(${_NAME}_FIND_VERSION_EXACT)       # exact version required
-        IF (NOT "${${_NAME}_FIND_VERSION}" VERSION_EQUAL "${VERSION}")
-          SET(VERSION_MSG " Found version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
-          SET(VERSION_OK FALSE)
-        ELSE (NOT "${${_NAME}_FIND_VERSION}" VERSION_EQUAL "${VERSION}")
-          SET(VERSION_MSG " (found exact version \"${VERSION}\")")
-        ENDIF (NOT "${${_NAME}_FIND_VERSION}" VERSION_EQUAL "${VERSION}")
-
-      ELSE(${_NAME}_FIND_VERSION_EXACT)     # minimum version specified:
-        IF ("${${_NAME}_FIND_VERSION}" VERSION_GREATER "${VERSION}")
-          SET(VERSION_MSG " Found version \"${VERSION}\", but required is at least \"${${_NAME}_FIND_VERSION}\"")
-          SET(VERSION_OK FALSE)
-        ELSE ("${${_NAME}_FIND_VERSION}" VERSION_GREATER "${VERSION}")
-          SET(VERSION_MSG " (found version \"${VERSION}\", required is \"${${_NAME}_FIND_VERSION}\")")
-        ENDIF ("${${_NAME}_FIND_VERSION}" VERSION_GREATER "${VERSION}")
-      ENDIF(${_NAME}_FIND_VERSION_EXACT)
-
-      ELSE(VERSION)
-        SET(VERSION_MSG " (WARNING: Required version is \"${${_NAME}_FIND_VERSION}\", but version of ${_NAME} is unknown)")
+      SET(VERSION ${${FPHSA_VERSION_VAR}} )
+
+      IF(VERSION)
+
+        IF(${_NAME}_FIND_VERSION_EXACT)       # exact version required
+          IF (NOT "${${_NAME}_FIND_VERSION}" VERSION_EQUAL "${VERSION}")
+            SET(VERSION_MSG " Found version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
+            SET(VERSION_OK FALSE)
+          ELSE (NOT "${${_NAME}_FIND_VERSION}" VERSION_EQUAL "${VERSION}")
+            SET(VERSION_MSG " (found exact version \"${VERSION}\")")
+          ENDIF (NOT "${${_NAME}_FIND_VERSION}" VERSION_EQUAL "${VERSION}")
+
+        ELSE(${_NAME}_FIND_VERSION_EXACT)     # minimum version specified:
+          IF ("${${_NAME}_FIND_VERSION}" VERSION_GREATER "${VERSION}")
+            SET(VERSION_MSG " Found version \"${VERSION}\", but required is at least \"${${_NAME}_FIND_VERSION}\"")
+            SET(VERSION_OK FALSE)
+          ELSE ("${${_NAME}_FIND_VERSION}" VERSION_GREATER "${VERSION}")
+            SET(VERSION_MSG " (found version \"${VERSION}\", required is \"${${_NAME}_FIND_VERSION}\")")
+          ENDIF ("${${_NAME}_FIND_VERSION}" VERSION_GREATER "${VERSION}")
+        ENDIF(${_NAME}_FIND_VERSION_EXACT)
+
+# Uncomment the following two lines to see to which Find-modules the VERSION_VAR keywords still need to be added:
+#      ELSE(VERSION)
+#        SET(VERSION_MSG " (WARNING: Required version is \"${${_NAME}_FIND_VERSION}\", but version of ${_NAME} is unknown)")
       ENDIF(VERSION)
 
-    # if the package was not found, but some a version was given, add that to the output:
+    # if the package was not found, but a version was given, add that to the output:
     ELSE (${_NAME_UPPER}_FOUND)
       IF(${_NAME}_FIND_VERSION_EXACT)
          SET(VERSION_MSG " (Required is exact version \"${${_NAME}_FIND_VERSION}\")")
@@ -113,7 +172,7 @@ FUNCTION(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FAIL_MSG _VAR1 )
   ENDIF (${_NAME}_FIND_VERSION)
 
   IF(VERSION_OK)
-      SET(DETAILS "${DETAILS}[v${${VERSION}}]")
+    SET(DETAILS "${DETAILS}[v${VERSION}]")
   ELSE(VERSION_OK)
     SET(${_NAME_UPPER}_FOUND FALSE)
   ENDIF(VERSION_OK)
@@ -121,25 +180,25 @@ FUNCTION(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FAIL_MSG _VAR1 )
 
   # print the result:
   IF (${_NAME_UPPER}_FOUND)
-    FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_VAR1}} ${VERSION_MSG}" "${DETAILS}")
+    FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG}" "${DETAILS}")
   ELSE (${_NAME_UPPER}_FOUND)
     IF(NOT VERSION_OK)
 
       IF (${_NAME}_FIND_REQUIRED)
-          MESSAGE(FATAL_ERROR "${_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_VAR1}})")
+          MESSAGE(FATAL_ERROR "${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_FIRST_REQUIRED_VAR}})")
       ELSE (${_NAME}_FIND_REQUIRED)
         IF (NOT ${_NAME}_FIND_QUIETLY)
-          MESSAGE(STATUS "${_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_VAR1}})")
+          MESSAGE(STATUS "${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_FIRST_REQUIRED_VAR}})")
         ENDIF (NOT ${_NAME}_FIND_QUIETLY)
       ENDIF (${_NAME}_FIND_REQUIRED)
 
     ELSE(NOT VERSION_OK)
 
       IF (${_NAME}_FIND_REQUIRED)
-          MESSAGE(FATAL_ERROR "${_FAIL_MESSAGE} (missing: ${MISSING_VARS}) ${VERSION_MSG}")
+          MESSAGE(FATAL_ERROR "${FPHSA_FAIL_MESSAGE} (missing: ${MISSING_VARS}) ${VERSION_MSG}")
       ELSE (${_NAME}_FIND_REQUIRED)
         IF (NOT ${_NAME}_FIND_QUIETLY)
-          MESSAGE(STATUS "${_FAIL_MESSAGE}  (missing: ${MISSING_VARS}) ${VERSION_MSG}")
+          MESSAGE(STATUS "${FPHSA_FAIL_MESSAGE}  (missing: ${MISSING_VARS}) ${VERSION_MSG}")
         ENDIF (NOT ${_NAME}_FIND_QUIETLY)
       ENDIF (${_NAME}_FIND_REQUIRED)
     ENDIF(NOT VERSION_OK)
@@ -148,4 +207,4 @@ FUNCTION(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FAIL_MSG _VAR1 )
 
   SET(${_NAME_UPPER}_FOUND ${${_NAME_UPPER}_FOUND} PARENT_SCOPE)
 
-ENDFUNCTION(FIND_PACKAGE_HANDLE_STANDARD_ARGS)
+ENDFUNCTION(FIND_PACKAGE_HANDLE_STANDARD_ARGS _FIRST_ARG)