From kde-buildsystem Tue Aug 24 20:19:23 2010 From: Alexander Neundorf Date: Tue, 24 Aug 2010 20:19:23 +0000 To: kde-buildsystem Subject: Re: build failure with recent cmake Message-Id: <201008242219.23305.neundorf () kde ! org> X-MARC-Message: https://marc.info/?l=kde-buildsystem&m=128268129226033 MIME-Version: 1 Content-Type: multipart/mixed; boundary="--Boundary-00=_LlCdMT2Tlzwulul" --Boundary-00=_LlCdMT2Tlzwulul Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: 7bit Content-Disposition: inline On Sunday 22 August 2010, Alexander Neundorf wrote: > On Sunday 22 August 2010, Oswald Buddenhagen wrote: > > moin, > > > > kdelibs fails to compile for me, suddenly not finding libz and libpng. > > the following message may be indicative for the problem: > > > > -- REQUIRED_VARS (missing: VERSION_VAR) > > -- Could NOT find PNG (missing: PNG_LIBRARY PNG_PNG_INCLUDE_DIR) > > > > that happens with the cmake release branch from git. running > > git checkout b6c8d8f8^ && make install > > fixes the problem. i haven't tried to verify whether this merge is > > actually to blame. > > Thanks for letting me know. > This is because we have a copy of FindPackageHandleStandardArgs.cmake, and > the version in cmake now supports extended syntax, but the find-modules > which we use from cmake now get out FindPackageHandleStandardArgs.cmake, > which cannot (yet) handle this additional arguments. > I have a look at it. Please try the attached patch. It syncs FindPackageHandleStandardArgs.cmake with the version from current cmake. This fixes the problem here, but I don't have all the packages installed. Please let me know if it works for you. Alex --Boundary-00=_LlCdMT2Tlzwulul Content-Type: text/x-diff; charset="iso-8859-1"; name="FPHSA-sync-with-cmake.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="FPHSA-sync-with-cmake.patch" Index: FindEigen2.cmake =================================================================== --- FindEigen2.cmake (revision 1167510) +++ FindEigen2.cmake (working copy) @@ -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,27 +33,8 @@ 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}) +endmacro(_eigen2_get_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) - find_path(EIGEN2_INCLUDE_DIR NAMES Eigen/Core PATHS ${INCLUDE_INSTALL_DIR} @@ -68,13 +43,13 @@ ) 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) Index: CMakeParseArguments.cmake =================================================================== --- CMakeParseArguments.cmake (revision 0) +++ CMakeParseArguments.cmake (revision 0) @@ -0,0 +1,138 @@ +# CMAKE_PARSE_ARGUMENTS( 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 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 argument contains all keywords for this macro +# which are followed by one value, like e.g. DESTINATION keyword of the +# install() command. +# +# The 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 , and +# a variable composed of the given +# followed by "_" and the name of the respective keyword. +# These variables will then hold the respective value from the argument list. +# For the keywords this will be TRUE or FALSE. +# +# All remaining arguments are collected in a variable +# _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 +# +# 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) Property changes on: CMakeParseArguments.cmake ___________________________________________________________________ Name: svn:eol-style + native Index: CMakeLists.txt =================================================================== --- CMakeLists.txt (revision 1167510) +++ CMakeLists.txt (working copy) @@ -10,13 +10,10 @@ 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 @@ 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 @@ 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 @@ 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 #) Index: FindPackageHandleStandardArgs.cmake =================================================================== --- FindPackageHandleStandardArgs.cmake (revision 1167510) +++ FindPackageHandleStandardArgs.cmake (working copy) @@ -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 _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 _VERSION with the specified version. -# Example: +# FIND_PACKAGE_HANDLE_STANDARD_ARGS( ... ) # -# 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 _FOUND variable. +# The package is considered found if all variables ... 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( (DEFAULT_MSG|"Custom failure message") ... ) +# If the variables to are all valid, then _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 ...] +# [VERSION_VAR +# [FAIL_MESSAGE "Custom failure message"] ) +# +# As above, if through are all valid, _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 . +# 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,18 +64,52 @@ # 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) - 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") +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) + + 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) # collect all variables which were not found, so they can be printed, so the @@ -49,15 +117,8 @@ 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 @@ ENDIF(NOT ${_CURRENT_VAR}) ENDFOREACH(_CURRENT_VAR) + # version handling: SET(VERSION_MSG "") SET(VERSION_OK TRUE) @@ -73,36 +135,33 @@ # if the package was found, check for the version using _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 + SET(VERSION ${${FPHSA_VERSION_VAR}} ) - 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}") + IF(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) + 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(VERSION) - SET(VERSION_MSG " (WARNING: Required version is \"${${_NAME}_FIND_VERSION}\", but version of ${_NAME} is unknown)") + 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 @@ 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 @@ # 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 @@ SET(${_NAME_UPPER}_FOUND ${${_NAME_UPPER}_FOUND} PARENT_SCOPE) -ENDFUNCTION(FIND_PACKAGE_HANDLE_STANDARD_ARGS) +ENDFUNCTION(FIND_PACKAGE_HANDLE_STANDARD_ARGS _FIRST_ARG) --Boundary-00=_LlCdMT2Tlzwulul Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Kde-buildsystem mailing list Kde-buildsystem@kde.org https://mail.kde.org/mailman/listinfo/kde-buildsystem --Boundary-00=_LlCdMT2Tlzwulul--