Updated LibFindMacros.cmake

Allowing much simplified CMake package  finder scripts, also moving to
finders creating imported targets.

CMake/Modules/Findhamlib.cmake

@@ -10,79 +10,42 @@
 # If hamlib_STATIC is TRUE then static linking will be assumed
 #
 
+# function(dump_cmake_variables)
+#   get_cmake_property(_variableNames VARIABLES)
+#   list (SORT _variableNames)
+#   foreach (_variableName ${_variableNames})
+#     if (ARGV0)
+#       unset(MATCHED)
+#       string(REGEX MATCH ${ARGV0} MATCHED ${_variableName})
+#       if (NOT MATCHED)
+#         continue()
+#       endif()
+#     endif()
+#     message(STATUS "${_variableName}=${${_variableName}}")
+#   endforeach()
+# endfunction()
+
 include (LibFindMacros)
 
-set (hamlib_LIBRARY_DIRS)
+libfind_pkg_detect (hamlib hamlib FIND_PATH hamlib/rig.h PATH_SUFFIXES hamlib FIND_LIBRARY hamlib)
-
+libfind_package (hamlib libusb)
-# pkg-config?
+if (hamlib_STATIC)
-find_path (__hamlib_pc_path NAMES hamlib.pc
+  if (hamlib_PKGCONF_FOUND)
-  PATH_SUFFIXES lib/pkgconfig lib64/pkgconfig
+    set (hamlib_PROCESS_LIBS hamlib_PKGCONF_STATIC_LIBRARY)
-  )
-if (__hamlib_pc_path)
-  set (__pc_path $ENV{PKG_CONFIG_PATH})
-  list (APPEND __pc_path "${__hamlib_pc_path}")
-  set (ENV{PKG_CONFIG_PATH} "${__pc_path}")
-  unset (__pc_path CACHE)
-endif ()
-unset (__hamlib_pc_path CACHE)
-
-# Use pkg-config to get hints about paths, libs and, flags
-unset (__pkg_config_checked_hamlib CACHE)
-# pkg_config will fail on Windows if the Hamlib USB backends are
-# configured since libusb-1.0 does not ship with a pkg_config file on
-# Windows, that's OK because we fix it up below
-libfind_pkg_check_modules (PC_HAMLIB hamlib)
-
-if (NOT PC_HAMLIB_FOUND)
-  # The headers
-  find_path (hamlib_INCLUDEDIR hamlib/rig.h)
-  # The libraries
-  if (hamlib_STATIC)
-    libfind_library (hamlib libhamlib.a)
   else ()
-    libfind_library (hamlib hamlib)
   endif ()
-  if (WIN32)
-    set (hamlib_EXTRA_LIBRARIES ws2_32)
-  else ()
-    set (hamlib_EXTRA_LIBRARIES m dl)
-  endif ()
-
-  # libusb-1.0 has no pkg-config file on Windows so we have to find it
-  # ourselves
-  if (CMAKE_SIZEOF_VOID_P MATCHES "8")
-    find_library (LIBUSB NAMES usb-1.0 PATH_SUFFIXES MinGW64/dll)
-  else ()
-    find_library (LIBUSB NAMES usb-1.0 PATH_SUFFIXES MinGW32/dll)
-  endif ()
-  if (LIBUSB)
-    set (hamlib_EXTRA_LIBRARIES ${LIBUSB} ${hamlib_EXTRA_LIBRARIES})
-    get_filename_component (hamlib_libusb_path ${LIBUSB} PATH)
-    set (hamlib_LIBRARY_DIRS ${hamlib_LIBRARY_DIRS} ${hamlib_libusb_path})
-  endif (LIBUSB)
-  set (hamlib_PROCESS_INCLUDES hamlib_INCLUDEDIR)
-  set (hamlib_PROCESS_LIBS hamlib_LIBRARY hamlib_EXTRA_LIBRARIES)
 else ()
-  if (hamlib_STATIC)
+  if (hamlib_PKGCONF_FOUND)
-    set (hamlib_PROCESS_INCLUDES PC_HAMLIB_STATIC_INCLUDE_DIRS)
+    set (hamlib_PROCESS_LIBS hamlib_PKGCONF_LIBRARY)
-    set (hamlib_PROCESS_LIBS PC_HAMLIB_STATIC_LDFLAGS)
-    set (hamlib_LIBRARY_DIRS ${PC_HAMLIB_STATIC_LIBRARY_DIRS})
   else ()
-    set (hamlib_PROCESS_INCLUDES PC_HAMLIB_INCLUDE_DIRS)
-    set (hamlib_PROCESS_LIBS PC_HAMLIB_LDFLAGS)
-    set (hamlib_LIBRARY_DIRS ${PC_HAMLIB_LIBRARY_DIRS})
   endif ()
 endif ()
 libfind_process (hamlib)
 
-if (WIN32)
+if (NOT hamlib_PKGCONF_FOUND)
-  find_path (hamlib_dll_path libhamlib-2.dll)
+  if (WIN32)
-  if (hamlib_dll_path)
+    set (hamlib_LIBRARIES ${hamlib_LIBRARIES};ws2_32)
-    set (hamlib_LIBRARY_DIRS ${hamlib_LIBRARY_DIRS} ${hamlib_dll_path})
+  else ()
+    set (hamlib_LIBRARIES ${hamlib_LIBRARIES};m;dl)
   endif ()
 endif ()
-
-# Handle the  QUIETLY and REQUIRED  arguments and set  HAMLIB_FOUND to
-# TRUE if all listed variables are TRUE
-include (FindPackageHandleStandardArgs)
-find_package_handle_standard_args (hamlib DEFAULT_MSG hamlib_INCLUDE_DIRS hamlib_LIBRARIES hamlib_LIBRARY_DIRS)

CMake/Modules/Findlibusb.cmake

@@ -15,21 +15,6 @@
 # If libusb_STATIC is TRUE then static linking will be assumed
 #
 
-function(dump_cmake_variables)
-  get_cmake_property(_variableNames VARIABLES)
-  list (SORT _variableNames)
-  foreach (_variableName ${_variableNames})
-    if (ARGV0)
-      unset(MATCHED)
-      string(REGEX MATCH ${ARGV0} MATCHED ${_variableName})
-      if (NOT MATCHED)
-        continue()
-      endif()
-    endif()
-    message(STATUS "${_variableName}=${${_variableName}}")
-  endforeach()
-endfunction()
-
 include (LibFindMacros)
 
 # Use pkg-config to get hints about paths, libs and, flags
@@ -37,8 +22,9 @@ libfind_pkg_check_modules (libusb_PC libusb-1.0)
 
 # Include dir
 find_path (libusb_INCLUDE_DIR
-  NAMES libusb.h
+  libusb.h
   PATHS ${libusb_PC_INCLUDE_DIRS}
+  PATH_SUFFIXES libusb-1.0
   )
 
 # Library
@@ -56,7 +42,6 @@ endif ()
 set (libusb_PROCESS_INCLUDES libusb_INCLUDE_DIR)
 set (libusb_PROCESS_LIBS libusb_LIBRARY)
 libfind_process (libusb)
-#dump_cmake_variables ("[lL][iI][bB][uU][sS]")
 
 include (FindPackageHandleStandardArgs)
 find_package_handle_standard_args (libusb

CMake/Modules/Findportaudio.cmake

@@ -12,70 +12,36 @@
 # If portaudio_STATIC is TRUE then static linking will be assumed
 #
 
-function(dump_cmake_variables)
+# function(dump_cmake_variables)
-  get_cmake_property(_variableNames VARIABLES)
+#   get_cmake_property(_variableNames VARIABLES)
-  list (SORT _variableNames)
+#   list (SORT _variableNames)
-  foreach (_variableName ${_variableNames})
+#   foreach (_variableName ${_variableNames})
-    if (ARGV0)
+#     if (ARGV0)
-      unset(MATCHED)
+#       unset(MATCHED)
-      string(REGEX MATCH ${ARGV0} MATCHED ${_variableName})
+#       string(REGEX MATCH ${ARGV0} MATCHED ${_variableName})
-      if (NOT MATCHED)
+#       if (NOT MATCHED)
-        continue()
+#         continue()
-      endif()
+#       endif()
-    endif()
+#     endif()
-    message(STATUS "${_variableName}=${${_variableName}}")
+#     message(STATUS "${_variableName}=${${_variableName}}")
-  endforeach()
+#   endforeach()
-endfunction()
+# endfunction()
 
 include (LibFindMacros)
 
-# Use pkg-config to get hints about paths, libs and, flags
+libfind_pkg_detect (portaudio portaudio-2.0 FIND_PATH portaudio.h FIND_LIBRARY portaudio)
-libfind_pkg_check_modules (portaudio_PC portaudio-2.0)
+set (portaudio_PROCESS_LIBS portaudio_PKGCONF_LDFLAGS)
-
-# Include dir
-find_path (portaudio_INCLUDE_DIR
-  NAMES portaudio.h
-  PATHS ${portaudio_PC_INCLUDE_DIRS}
-  )
-
-# Library
-if (portaudio_STATIC)
-  find_library (portaudio_LIBRARY
-    NAMES portaudio
-    PATHS ${portaudio_PC_STATIC_LIBRARY_DIRS}
-    )
-else ()
-  find_library (portaudio_LIBRARY
-    NAMES portaudio
-    PATHS ${portaudio_PC_LIBRARY_DIRS}
-    )
-endif ()
-set (portaudio_PROCESS_INCLUDES portaudio_INCLUDE_DIR)
-set (portaudio_PROCESS_LIBS portaudio_LIBRARY)
 libfind_process (portaudio)
 
-# Handle the  QUIETLY and REQUIRED  arguments and set  PORTAUDIO_FOUND to
+#dump_cmake_variables ("^portaudio_")
-# TRUE if all listed variables are TRUE
-include (FindPackageHandleStandardArgs)
-find_package_handle_standard_args (portaudio
-  REQUIRED_VARS
-     portaudio_LIBRARY
-     portaudio_INCLUDE_DIR
-  VERSION_VAR portaudio_VERSION
-  )
-
-if (portaudio_FOUND)
-  set (portaudio_LIBRARIES ${portaudio_LIBRARY})
-  set (portaudio_INCLUDE_DIRS ${portaudio_INCLUDE_DIR})
-  set (portaudio_DEFINITIONS ${portaudio_CFLAGS_OTHER})
-endif ()
 
 if (portaudio_FOUND AND NOT TARGET portaudio::portaudio)
   add_library (portaudio::portaudio UNKNOWN IMPORTED)
   set_target_properties (portaudio::portaudio PROPERTIES
     IMPORTED_LOCATION "${portaudio_LIBRARY}"
-    INTERFACE_COMPILE_OPTIONS "${portaudio_CFLAGS_OTHER}"
+    INTERFACE_COMPILE_OPTIONS "${portaudio_CFLAGS_OTHERS}"
-    INTERFACE_INCLUDE_DIRECTORIES "${portaudio_INCLUDE_DIR}"
+    INTERFACE_INCLUDE_DIRECTORIES "${portaudio_INCLUDE_DIRS}"
+    INTERFACE_LINK_LIBRARIES "${portaudio_LIBRARIES}"
     )
 endif ()
 

CMake/Modules/LibFindMacros.cmake

@@ -1,46 +1,101 @@
-# Version 1.0 (2013-04-12)
+# Version 2.3
-# Public Domain, originally written by Lasse Kärkkäinen <tronic@zi.fi>
+# Public Domain, originally written by Lasse Kärkkäinen <tronic>
-# Published at http://www.cmake.org/Wiki/CMake:How_To_Find_Libraries
+# Maintained at https://github.com/Tronic/cmake-modules
+# Please send your improvements as pull requests on Github.
 
-# If you improve the script, please modify the forementioned wiki page because
+# Find another package and make it a dependency of the current package.
-# I no longer maintain my scripts (hosted as static files at zi.fi). Feel free
+# This also automatically forwards the "REQUIRED" argument.
-# to remove this entire header if you use real version control instead.
+# Usage: libfind_package(<prefix> <another package> [extra args to find_package])
-
+macro (libfind_package PREFIX PKG)
-# Changelog:
+  set(${PREFIX}_args ${PKG} ${ARGN})
-# 2013-04-12  Added version number (1.0) and this header, no other changes
-# 2009-10-08  Originally published
-
-
-# Works the same as find_package, but forwards the "REQUIRED" and "QUIET" arguments
-# used for the current package. For this to work, the first parameter must be the
-# prefix of the current package, then the prefix of the new package etc, which are
-# passed to find_package.
-macro (libfind_package PREFIX)
-  set (LIBFIND_PACKAGE_ARGS ${ARGN})
-  if (${PREFIX}_FIND_QUIETLY)
-    set (LIBFIND_PACKAGE_ARGS ${LIBFIND_PACKAGE_ARGS} QUIET)
-  endif (${PREFIX}_FIND_QUIETLY)
   if (${PREFIX}_FIND_REQUIRED)
-    set (LIBFIND_PACKAGE_ARGS ${LIBFIND_PACKAGE_ARGS} REQUIRED)
+    set(${PREFIX}_args ${${PREFIX}_args} REQUIRED)
-  endif (${PREFIX}_FIND_REQUIRED)
+  endif()
-  find_package(${LIBFIND_PACKAGE_ARGS})
+  find_package(${${PREFIX}_args})
-endmacro (libfind_package)
+  set(${PREFIX}_DEPENDENCIES ${${PREFIX}_DEPENDENCIES};${PKG})
+  unset(${PREFIX}_args)
+endmacro()
 
-# CMake developers made the UsePkgConfig system deprecated in the same release (2.6)
+# A simple wrapper to make pkg-config searches a bit easier.
-# where they added pkg_check_modules. Consequently I need to support both in my scripts
+# Works the same as CMake's internal pkg_check_modules but is always quiet.
-# to avoid those deprecated warnings. Here's a helper that does just that.
+macro (libfind_pkg_check_modules)
-# Works identically to pkg_check_modules, except that no checks are needed prior to use.
+  find_package(PkgConfig QUIET)
-macro (libfind_pkg_check_modules PREFIX PKGNAME)
+  if (PKG_CONFIG_FOUND)
-  if (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
+    pkg_check_modules(${ARGN} QUIET)
-    include(UsePkgConfig)
+  endif()
-    pkgconfig(${PKGNAME} ${PREFIX}_INCLUDE_DIRS ${PREFIX}_LIBRARY_DIRS ${PREFIX}_LDFLAGS ${PREFIX}_CFLAGS)
+endmacro()
-  else (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
+
-    find_package(PkgConfig)
+# Avoid useless copy&pasta by doing what most simple libraries do anyway:
-    if (PKG_CONFIG_FOUND)
+# pkg-config, find headers, find library.
-      pkg_check_modules(${PREFIX} ${PKGNAME})
+# Usage: libfind_pkg_detect(<prefix> <pkg-config args> FIND_PATH <name> [other args] FIND_LIBRARY <name> [other args])
-    endif (PKG_CONFIG_FOUND)
+# E.g. libfind_pkg_detect(SDL2 sdl2 FIND_PATH SDL.h PATH_SUFFIXES SDL2 FIND_LIBRARY SDL2)
-  endif (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
+function (libfind_pkg_detect PREFIX)
-endmacro (libfind_pkg_check_modules)
+  # Parse arguments
+  set(argname pkgargs)
+  foreach (i ${ARGN})
+    if ("${i}" STREQUAL "FIND_PATH")
+      set(argname pathargs)
+    elseif ("${i}" STREQUAL "FIND_LIBRARY")
+      set(argname libraryargs)
+    else()
+      set(${argname} ${${argname}} ${i})
+    endif()
+  endforeach()
+  if (NOT pkgargs)
+    message(FATAL_ERROR "libfind_pkg_detect requires at least a pkg_config package name to be passed.")
+  endif()
+  # Find library
+  libfind_pkg_check_modules(${PREFIX}_PKGCONF ${pkgargs})
+  if (pathargs)
+    find_path(${PREFIX}_INCLUDE_DIR NAMES ${pathargs} HINTS ${${PREFIX}_PKGCONF_INCLUDE_DIRS})
+  endif()
+  if (libraryargs)
+    find_library(${PREFIX}_LIBRARY NAMES ${libraryargs} HINTS ${${PREFIX}_PKGCONF_LIBRARY_DIRS})
+  endif()
+  # Read pkg-config version
+  if (${PREFIX}_PKGCONF_VERSION)
+    set(${PREFIX}_VERSION ${${PREFIX}_PKGCONF_VERSION} PARENT_SCOPE)
+  endif()
+endfunction()
+
+# Extracts a version #define from a version.h file, output stored to <PREFIX>_VERSION.
+# Usage: libfind_version_header(Foobar foobar/version.h FOOBAR_VERSION_STR)
+# Fourth argument "QUIET" may be used for silently testing different define names.
+# This function does nothing if the version variable is already defined.
+function (libfind_version_header PREFIX VERSION_H DEFINE_NAME)
+  # Skip processing if we already have a version or if the include dir was not found
+  if (${PREFIX}_VERSION OR NOT ${PREFIX}_INCLUDE_DIR)
+    return()
+  endif()
+  set(quiet ${${PREFIX}_FIND_QUIETLY})
+  # Process optional arguments
+  foreach(arg ${ARGN})
+    if (arg STREQUAL "QUIET")
+      set(quiet TRUE)
+    else()
+      message(AUTHOR_WARNING "Unknown argument ${arg} to libfind_version_header ignored.")
+    endif()
+  endforeach()
+  # Read the header and parse for version number
+  set(filename "${${PREFIX}_INCLUDE_DIR}/${VERSION_H}")
+  if (NOT EXISTS ${filename})
+    if (NOT quiet)
+      message(AUTHOR_WARNING "Unable to find ${${PREFIX}_INCLUDE_DIR}/${VERSION_H}")
+    endif()
+    return()
+  endif()
+  file(READ "${filename}" header)
+  string(REGEX REPLACE ".*#[ \t]*define[ \t]*${DEFINE_NAME}[ \t]*\"([^\n]*)\".*" "\\1" match "${header}")
+  # No regex match?
+  if (match STREQUAL header)
+    if (NOT quiet)
+      message(AUTHOR_WARNING "Unable to find \#define ${DEFINE_NAME} \"<version>\" from ${${PREFIX}_INCLUDE_DIR}/${VERSION_H}")
+    endif()
+    return()
+  endif()
+  # Export the version string
+  set(${PREFIX}_VERSION "${match}" PARENT_SCOPE)
+endfunction()
 
 # Do the final processing once the paths have been detected.
 # If include dirs are needed, ${PREFIX}_PROCESS_INCLUDES should be set to contain
@@ -48,65 +103,167 @@ endmacro (libfind_pkg_check_modules)
 # Ditto for ${PREFIX}_PROCESS_LIBS and library files.
 # Will set ${PREFIX}_FOUND, ${PREFIX}_INCLUDE_DIRS and ${PREFIX}_LIBRARIES.
 # Also handles errors in case library detection was required, etc.
-macro (libfind_process PREFIX)
+function (libfind_process PREFIX)
-  # Skip processing if already processed during this run
+  # Skip processing if already processed during this configuration run
-  if (NOT ${PREFIX}_FOUND)
+  if (${PREFIX}_FOUND)
-    # Start with the assumption that the library was found
+    return()
-    set (${PREFIX}_FOUND TRUE)
+  endif()
 
-    # Process all includes and set _FOUND to false if any are missing
+  set(found TRUE)  # Start with the assumption that the package was found
-    foreach (i ${${PREFIX}_PROCESS_INCLUDES})
-      if (${i})
-        set (${PREFIX}_INCLUDE_DIRS ${${PREFIX}_INCLUDE_DIRS} ${${i}})
-        mark_as_advanced(${i})
-      else (${i})
-        set (${PREFIX}_FOUND FALSE)
-      endif (${i})
-    endforeach (i)
 
-    # Process all libraries and set _FOUND to false if any are missing
+  # Did we find any files? Did we miss includes? These are for formatting better error messages.
-    foreach (i ${${PREFIX}_PROCESS_LIBS})
+  set(some_files FALSE)
-      if (${i})
+  set(missing_headers FALSE)
-        set (${PREFIX}_LIBRARIES ${${PREFIX}_LIBRARIES} ${${i}})
-        mark_as_advanced(${i})
-      else (${i})
-        set (${PREFIX}_FOUND FALSE)
-      endif (${i})
-    endforeach (i)
 
-    # Print message and/or exit on fatal error
+  # Shorthands for some variables that we need often
-    if (${PREFIX}_FOUND)
+  set(quiet ${${PREFIX}_FIND_QUIETLY})
-      if (NOT ${PREFIX}_FIND_QUIETLY)
+  set(required ${${PREFIX}_FIND_REQUIRED})
-        message (STATUS "Found ${PREFIX} ${${PREFIX}_VERSION}")
+  set(exactver ${${PREFIX}_FIND_VERSION_EXACT})
-      endif (NOT ${PREFIX}_FIND_QUIETLY)
+  set(findver "${${PREFIX}_FIND_VERSION}")
-    else (${PREFIX}_FOUND)
+  set(version "${${PREFIX}_VERSION}")
-      if (${PREFIX}_FIND_REQUIRED)
-        foreach (i ${${PREFIX}_PROCESS_INCLUDES} ${${PREFIX}_PROCESS_LIBS})
-          message("${i}=${${i}}")
-        endforeach (i)
-        message (FATAL_ERROR "Required library ${PREFIX} NOT FOUND.\nInstall the library (dev version) and try again. If the library is already installed, use ccmake to set the missing variables manually.")
-      endif (${PREFIX}_FIND_REQUIRED)
-    endif (${PREFIX}_FOUND)
-  endif (NOT ${PREFIX}_FOUND)
-endmacro (libfind_process)
 
-macro(libfind_library PREFIX basename)
+  # Lists of config option names (all, includes, libs)
-  set(TMP "")
+  unset(configopts)
-  if(MSVC80)
+  set(includeopts ${${PREFIX}_PROCESS_INCLUDES})
-    set(TMP -vc80)
+  set(libraryopts ${${PREFIX}_PROCESS_LIBS})
-  endif(MSVC80)
-  if(MSVC90)
-    set(TMP -vc90)
-  endif(MSVC90)
-  set(${PREFIX}_LIBNAMES ${basename}${TMP})
-  if(${ARGC} GREATER 2)
-    set(${PREFIX}_LIBNAMES ${basename}${TMP}-${ARGV2})
-    string(REGEX REPLACE "\\." "_" TMP ${${PREFIX}_LIBNAMES})
-    set(${PREFIX}_LIBNAMES ${${PREFIX}_LIBNAMES} ${TMP})
-  endif(${ARGC} GREATER 2)
-  find_library(${PREFIX}_LIBRARY
-    NAMES ${${PREFIX}_LIBNAMES}
-    PATHS ${${PREFIX}_PKGCONF_LIBRARY_DIRS}
-  )
-endmacro(libfind_library)
 
+  # Process deps to add to
+  foreach (i ${PREFIX} ${${PREFIX}_DEPENDENCIES})
+    if (DEFINED ${i}_INCLUDE_OPTS OR DEFINED ${i}_LIBRARY_OPTS)
+      # The package seems to export option lists that we can use, woohoo!
+      list(APPEND includeopts ${${i}_INCLUDE_OPTS})
+      list(APPEND libraryopts ${${i}_LIBRARY_OPTS})
+    else()
+      # If plural forms don't exist or they equal singular forms
+      if ((NOT DEFINED ${i}_INCLUDE_DIRS AND NOT DEFINED ${i}_LIBRARIES) OR
+          (${i}_INCLUDE_DIR STREQUAL ${i}_INCLUDE_DIRS AND ${i}_LIBRARY STREQUAL ${i}_LIBRARIES))
+        # Singular forms can be used
+        if (DEFINED ${i}_INCLUDE_DIR)
+          list(APPEND includeopts ${i}_INCLUDE_DIR)
+        endif()
+        if (DEFINED ${i}_LIBRARY)
+          list(APPEND libraryopts ${i}_LIBRARY)
+        endif()
+      else()
+        # Oh no, we don't know the option names
+        message(FATAL_ERROR "We couldn't determine config variable names for ${i} includes and libs. Aieeh!")
+      endif()
+    endif()
+  endforeach()
+
+  if (includeopts)
+    list(REMOVE_DUPLICATES includeopts)
+  endif()
+
+  if (libraryopts)
+    list(REMOVE_DUPLICATES libraryopts)
+  endif()
+
+  string(REGEX REPLACE ".*[ ;]([^ ;]*(_INCLUDE_DIRS|_LIBRARIES))" "\\1" tmp "${includeopts} ${libraryopts}")
+  if (NOT tmp STREQUAL "${includeopts} ${libraryopts}")
+    message(AUTHOR_WARNING "Plural form ${tmp} found in config options of ${PREFIX}. This works as before but is now deprecated. Please only use singular forms INCLUDE_DIR and LIBRARY, and update your find scripts for LibFindMacros > 2.0 automatic dependency system (most often you can simply remove the PROCESS variables entirely).")
+  endif()
+
+  # Include/library names separated by spaces (notice: not CMake lists)
+  unset(includes)
+  unset(libs)
+
+  # Process all includes and set found false if any are missing
+  foreach (i ${includeopts})
+    list(APPEND configopts ${i})
+    if (NOT "${${i}}" STREQUAL "${i}-NOTFOUND")
+      list(APPEND includes "${${i}}")
+    else()
+      set(found FALSE)
+      set(missing_headers TRUE)
+    endif()
+  endforeach()
+
+  # Process all libraries and set found false if any are missing
+  foreach (i ${libraryopts})
+    list(APPEND configopts ${i})
+    if (NOT "${${i}}" STREQUAL "${i}-NOTFOUND")
+      list(APPEND libs "${${i}}")
+    else()
+      set (found FALSE)
+    endif()
+  endforeach()
+
+  # Version checks
+  if (found AND findver)
+    if (NOT version)
+      message(WARNING "The find module for ${PREFIX} does not provide version information, so we'll just assume that it is OK. Please fix the module or remove package version requirements to get rid of this warning.")
+    elseif (version VERSION_LESS findver OR (exactver AND NOT version VERSION_EQUAL findver))
+      set(found FALSE)
+      set(version_unsuitable TRUE)
+    endif()
+  endif()
+
+  # If all-OK, hide all config options, export variables, print status and exit
+  if (found)
+    foreach (i ${configopts})
+      mark_as_advanced(${i})
+    endforeach()
+    if (NOT quiet)
+      message(STATUS "Found ${PREFIX} ${${PREFIX}_VERSION}")
+      if (LIBFIND_DEBUG)
+        message(STATUS "  ${PREFIX}_DEPENDENCIES=${${PREFIX}_DEPENDENCIES}")
+        message(STATUS "  ${PREFIX}_INCLUDE_OPTS=${includeopts}")
+        message(STATUS "  ${PREFIX}_INCLUDE_DIRS=${includes}")
+        message(STATUS "  ${PREFIX}_LIBRARY_OPTS=${libraryopts}")
+        message(STATUS "  ${PREFIX}_LIBRARIES=${libs}")
+      endif()
+    endif()
+    set (${PREFIX}_INCLUDE_OPTS ${includeopts} PARENT_SCOPE)
+    set (${PREFIX}_LIBRARY_OPTS ${libraryopts} PARENT_SCOPE)
+    set (${PREFIX}_INCLUDE_DIRS ${includes} PARENT_SCOPE)
+    set (${PREFIX}_LIBRARIES ${libs} PARENT_SCOPE)
+    set (${PREFIX}_FOUND TRUE PARENT_SCOPE)
+    return()
+  endif()
+
+  # Format messages for debug info and the type of error
+  set(vars "Relevant CMake configuration variables:\n")
+  foreach (i ${configopts})
+    mark_as_advanced(CLEAR ${i})
+    set(val ${${i}})
+    if ("${val}" STREQUAL "${i}-NOTFOUND")
+      set (val "<not found>")
+    elseif (val AND NOT EXISTS ${val})
+      set (val "${val}  (does not exist)")
+    else()
+      set(some_files TRUE)
+    endif()
+    set(vars "${vars}  ${i}=${val}\n")
+  endforeach()
+  set(vars "${vars}You may use CMake GUI, cmake -D or ccmake to modify the values. Delete CMakeCache.txt to discard all values and force full re-detection if necessary.\n")
+  if (version_unsuitable)
+    set(msg "${PREFIX} ${${PREFIX}_VERSION} was found but")
+    if (exactver)
+      set(msg "${msg} only version ${findver} is acceptable.")
+    else()
+      set(msg "${msg} version ${findver} is the minimum requirement.")
+    endif()
+  else()
+    if (missing_headers)
+      set(msg "We could not find development headers for ${PREFIX}. Do you have the necessary dev package installed?")
+    elseif (some_files)
+      set(msg "We only found some files of ${PREFIX}, not all of them. Perhaps your installation is incomplete or maybe we just didn't look in the right place?")
+      if(findver)
+        set(msg "${msg} This could also be caused by incompatible version (if it helps, at least ${PREFIX} ${findver} should work).")
+      endif()
+    else()
+      set(msg "We were unable to find package ${PREFIX}.")
+    endif()
+  endif()
+
+  # Fatal error out if REQUIRED
+  if (required)
+    set(msg "REQUIRED PACKAGE NOT FOUND\n${msg} This package is REQUIRED and you need to install it or adjust CMake configuration in order to continue building ${CMAKE_PROJECT_NAME}.")
+    message(FATAL_ERROR "${msg}\n${vars}")
+  endif()
+  # Otherwise just print a nasty warning
+  if (NOT quiet)
+    message(WARNING "WARNING: MISSING PACKAGE\n${msg} This package is NOT REQUIRED and you may ignore this warning but by doing so you may miss some functionality of ${CMAKE_PROJECT_NAME}. \n${vars}")
+  endif()
+endfunction()

CMakeLists.txt

@@ -873,7 +873,7 @@ find_package (FFTW3 COMPONENTS single threads REQUIRED)
 # libhamlib setup
 #
 set (hamlib_STATIC 1)
-find_package (hamlib 3 REQUIRED)
+find_package (hamlib REQUIRED)
 find_program (RIGCTL_EXE rigctl)
 find_program (RIGCTLD_EXE rigctld)
 find_program (RIGCTLCOM_EXE rigctlcom)