FindHDF5.cmake 37.8 KB
Newer Older
1 2 3
# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.

4 5 6 7 8 9 10
#.rst:
# FindHDF5
# --------
#
# Find HDF5, a library for reading and writing self describing array data.
#
#
11 12
#
# This module invokes the HDF5 wrapper compiler that should be installed
13 14 15 16 17 18 19 20 21 22 23 24 25
# alongside HDF5.  Depending upon the HDF5 Configuration, the wrapper
# compiler is called either h5cc or h5pcc.  If this succeeds, the module
# will then call the compiler with the -show argument to see what flags
# are used when compiling an HDF5 client application.
#
# The module will optionally accept the COMPONENTS argument.  If no
# COMPONENTS are specified, then the find module will default to finding
# only the HDF5 C library.  If one or more COMPONENTS are specified, the
# module will attempt to find the language bindings for the specified
# components.  The only valid components are C, CXX, Fortran, HL, and
# Fortran_HL.  If the COMPONENTS argument is not given, the module will
# attempt to find only the C bindings.
#
26
# This module will read the variable
27 28 29 30 31 32 33 34 35 36
# HDF5_USE_STATIC_LIBRARIES to determine whether or not to prefer a
# static link to a dynamic link for HDF5 and all of it's dependencies.
# To use this feature, make sure that the HDF5_USE_STATIC_LIBRARIES
# variable is set before the call to find_package.
#
# To provide the module with a hint about where to find your HDF5
# installation, you can set the environment variable HDF5_ROOT.  The
# Find module will then look in this path when searching for HDF5
# executables, paths, and libraries.
#
37 38 39 40 41 42
# Both the serial and parallel HDF5 wrappers are considered and the first
# directory to contain either one will be used.  In the event that both appear
# in the same directory the serial version is preferentially selected. This
# behavior can be reversed by setting the variable HDF5_PREFER_PARALLEL to
# true.
#
43 44 45 46
# In addition to finding the includes and libraries required to compile
# an HDF5 client application, this module also makes an effort to find
# tools that come with the HDF5 distribution that may be useful for
# regression testing.
47
#
48
# This module will define the following variables:
49 50 51
#
# ::
#
52 53
#   HDF5_FOUND - true if HDF5 was found on the system
#   HDF5_VERSION - HDF5 version in format Major.Minor.Release
54 55 56
#   HDF5_INCLUDE_DIRS - Location of the hdf5 includes
#   HDF5_INCLUDE_DIR - Location of the hdf5 includes (deprecated)
#   HDF5_DEFINITIONS - Required compiler definitions for HDF5
57 58 59 60 61
#   HDF5_LIBRARIES - Required libraries for all requested bindings
#   HDF5_HL_LIBRARIES - Required libraries for the HDF5 high level API for all
#                       bindings, if the HL component is enabled
#
# Available components are: C CXX Fortran and HL.  For each enabled language
62 63
# binding, a corresponding HDF5_${LANG}_LIBRARIES variable, and potentially
# HDF5_${LANG}_DEFINITIONS, will be defined.
64 65 66 67 68
# If the HL component is enabled, then an HDF5_${LANG}_HL_LIBRARIES will
# also be defined.  With all components enabled, the following variables will be defined:
#
# ::
#
69 70 71
#   HDF5_C_DEFINITIONS -- Required compiler definitions for HDF5 C bindings
#   HDF5_CXX_DEFINITIONS -- Required compiler definitions for HDF5 C++ bindings
#   HDF5_Fortran_DEFINITIONS -- Required compiler definitions for HDF5 Fortran bindings
72 73 74
#   HDF5_C_INCLUDE_DIRS -- Required include directories for HDF5 C bindings
#   HDF5_CXX_INCLUDE_DIRS -- Required include directories for HDF5 C++ bindings
#   HDF5_Fortran_INCLUDE_DIRS -- Required include directories for HDF5 Fortran bindings
75
#   HDF5_C_LIBRARIES - Required libraries for the HDF5 C bindings
76 77
#   HDF5_CXX_LIBRARIES - Required libraries for the HDF5 C++ bindings
#   HDF5_Fortran_LIBRARIES - Required libraries for the HDF5 Fortran bindings
78 79
#   HDF5_C_HL_LIBRARIES - Required libraries for the high level C bindings
#   HDF5_CXX_HL_LIBRARIES - Required libraries for the high level C++ bindings
80 81
#   HDF5_Fortran_HL_LIBRARIES - Required libraries for the high level Fortran
#                               bindings.
82
#
83 84 85 86
#   HDF5_IS_PARALLEL - Whether or not HDF5 was found with parallel IO support
#   HDF5_C_COMPILER_EXECUTABLE - the path to the HDF5 C wrapper compiler
#   HDF5_CXX_COMPILER_EXECUTABLE - the path to the HDF5 C++ wrapper compiler
#   HDF5_Fortran_COMPILER_EXECUTABLE - the path to the HDF5 Fortran wrapper compiler
87 88 89 90 91 92 93 94
#   HDF5_C_COMPILER_EXECUTABLE_NO_INTERROGATE - path to the primary C compiler
#                                               which is also the HDF5 wrapper
#   HDF5_CXX_COMPILER_EXECUTABLE_NO_INTERROGATE - path to the primary C++
#                                                 compiler which is also
#                                                 the HDF5 wrapper
#   HDF5_Fortran_COMPILER_EXECUTABLE_NO_INTERROGATE - path to the primary
#                                                     Fortran compiler which
#                                                     is also the HDF5 wrapper
95
#   HDF5_DIFF_EXECUTABLE - the path to the HDF5 dataset comparison tool
96 97 98
#
# The following variable can be set to guide the search for HDF5 libraries and includes:
#
99 100
# ``HDF5_ROOT``
#   Specify the path to the HDF5 installation to use.
101
#
102 103
# ``HDF5_FIND_DEBUG``
#   Set to a true value to get some extra debugging output.
104
#
105 106
# ``HDF5_NO_FIND_PACKAGE_CONFIG_FILE``
#   Set to a true value to skip trying to find ``hdf5-config.cmake``.
107 108 109

# This module is maintained by Will Dicharry <wdicharry@stellarscience.com>.

110
include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake)
111
include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
112 113

# List of the valid HDF5 components
114
set(HDF5_VALID_LANGUAGE_BINDINGS C CXX Fortran)
115

116
# Validate the list of find components.
117
if(NOT HDF5_FIND_COMPONENTS)
118
  set(HDF5_LANGUAGE_BINDINGS "C")
119
else()
120
  set(HDF5_LANGUAGE_BINDINGS)
121 122 123 124 125 126 127 128 129 130 131
  # add the extra specified components, ensuring that they are valid.
  set(FIND_HL OFF)
  foreach(component IN LISTS HDF5_FIND_COMPONENTS)
    list(FIND HDF5_VALID_LANGUAGE_BINDINGS ${component} component_location)
    if(NOT component_location EQUAL -1)
      list(APPEND HDF5_LANGUAGE_BINDINGS ${component})
    elseif(component STREQUAL "HL")
      set(FIND_HL ON)
    elseif(component STREQUAL "Fortran_HL") # only for compatibility
      list(APPEND HDF5_LANGUAGE_BINDINGS Fortran)
      set(FIND_HL ON)
132 133 134
      set(HDF5_FIND_REQUIRED_Fortran_HL False)
      set(HDF5_FIND_REQUIRED_Fortran True)
      set(HDF5_FIND_REQUIRED_HL True)
135 136 137 138 139 140 141 142 143 144
    else()
      message(FATAL_ERROR "${component} is not a valid HDF5 component.")
    endif()
  endforeach()
  if(NOT HDF5_LANGUAGE_BINDINGS)
    get_property(__langs GLOBAL PROPERTY ENABLED_LANGUAGES)
    foreach(__lang IN LISTS __langs)
      if(__lang MATCHES "^(C|CXX|Fortran)$")
        list(APPEND HDF5_LANGUAGE_BINDINGS ${__lang})
      endif()
145
    endforeach()
146
  endif()
147
  list(REMOVE_ITEM HDF5_FIND_COMPONENTS Fortran_HL) # replaced by Fortran and HL
148
  list(REMOVE_DUPLICATES HDF5_LANGUAGE_BINDINGS)
149 150
endif()

151 152 153 154 155 156 157 158 159 160 161
# Determine whether to search for serial or parallel executable first
if(HDF5_PREFER_PARALLEL)
  set(HDF5_C_COMPILER_NAMES h5pcc h5cc)
  set(HDF5_CXX_COMPILER_NAMES h5pc++ h5c++)
  set(HDF5_Fortran_COMPILER_NAMES h5pfc h5fc)
else()
  set(HDF5_C_COMPILER_NAMES h5cc h5pcc)
  set(HDF5_CXX_COMPILER_NAMES h5c++ h5pc++)
  set(HDF5_Fortran_COMPILER_NAMES h5fc h5pfc)
endif()

162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
# We may have picked up some duplicates in various lists during the above
# process for the language bindings (both the C and C++ bindings depend on
# libz for example).  Remove the duplicates. It appears that the default
# CMake behavior is to remove duplicates from the end of a list. However,
# for link lines, this is incorrect since unresolved symbols are searched
# for down the link line. Therefore, we reverse the list, remove the
# duplicates, and then reverse it again to get the duplicates removed from
# the beginning.
macro(_HDF5_remove_duplicates_from_beginning _list_name)
  if(${_list_name})
    list(REVERSE ${_list_name})
    list(REMOVE_DUPLICATES ${_list_name})
    list(REVERSE ${_list_name})
  endif()
endmacro()
177

178

179 180
# Test first if the current compilers automatically wrap HDF5

181
function(_HDF5_test_regular_compiler_C success version is_parallel)
182 183 184 185 186 187 188 189
  set(scratch_directory
    ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/hdf5)
  if(NOT ${success} OR
     NOT EXISTS ${scratch_directory}/compiler_has_h5_c)
    set(test_file ${scratch_directory}/cmake_hdf5_test.c)
    file(WRITE ${test_file}
      "#include <hdf5.h>\n"
      "#include <hdf5_hl.h>\n"
190 191 192 193 194 195 196 197 198 199
      "const char* info_ver = \"INFO\" \":\" H5_VERSION;\n"
      "#ifdef H5_HAVE_PARALLEL\n"
      "const char* info_parallel = \"INFO\" \":\" \"PARALLEL\";\n"
      "#endif\n"
      "int main(int argc, char **argv) {\n"
      "  int require = 0;\n"
      "  require += info_ver[argc];\n"
      "#ifdef H5_HAVE_PARALLEL\n"
      "  require += info_parallel[argc];\n"
      "#endif\n"
200 201 202 203 204 205 206 207 208
      "  hid_t fid;\n"
      "  fid = H5Fcreate(\"foo.h5\",H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT);\n"
      "  return 0;\n"
      "}")
    try_compile(${success} ${scratch_directory} ${test_file}
      COPY_FILE ${scratch_directory}/compiler_has_h5_c
    )
  endif()
  if(${success})
209 210
    file(STRINGS ${scratch_directory}/compiler_has_h5_c INFO_STRINGS
      REGEX "^INFO:"
211 212
    )
    string(REGEX MATCH "^INFO:([0-9]+\\.[0-9]+\\.[0-9]+)(-patch([0-9]+))?"
213
      INFO_VER "${INFO_STRINGS}"
214 215 216 217 218 219
    )
    set(${version} ${CMAKE_MATCH_1})
    if(CMAKE_MATCH_3)
      set(${version} ${HDF5_CXX_VERSION}.${CMAKE_MATCH_3})
    endif()
    set(${version} ${${version}} PARENT_SCOPE)
220

221
    if(INFO_STRINGS MATCHES "INFO:PARALLEL")
222 223 224 225
      set(${is_parallel} TRUE PARENT_SCOPE)
    else()
      set(${is_parallel} FALSE PARENT_SCOPE)
    endif()
226 227 228
  endif()
endfunction()

229
function(_HDF5_test_regular_compiler_CXX success version is_parallel)
230 231 232 233 234 235 236 237 238
  set(scratch_directory ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/hdf5)
  if(NOT ${success} OR
     NOT EXISTS ${scratch_directory}/compiler_has_h5_cxx)
    set(test_file ${scratch_directory}/cmake_hdf5_test.cxx)
    file(WRITE ${test_file}
      "#include <H5Cpp.h>\n"
      "#ifndef H5_NO_NAMESPACE\n"
      "using namespace H5;\n"
      "#endif\n"
239 240 241 242
      "const char* info_ver = \"INFO\" \":\" H5_VERSION;\n"
      "#ifdef H5_HAVE_PARALLEL\n"
      "const char* info_parallel = \"INFO\" \":\" \"PARALLEL\";\n"
      "#endif\n"
243
      "int main(int argc, char **argv) {\n"
244 245 246 247 248
      "  int require = 0;\n"
      "  require += info_ver[argc];\n"
      "#ifdef H5_HAVE_PARALLEL\n"
      "  require += info_parallel[argc];\n"
      "#endif\n"
249 250 251 252 253 254 255 256
      "  H5File file(\"foo.h5\", H5F_ACC_TRUNC);\n"
      "  return 0;\n"
      "}")
    try_compile(${success} ${scratch_directory} ${test_file}
      COPY_FILE ${scratch_directory}/compiler_has_h5_cxx
    )
  endif()
  if(${success})
257 258
    file(STRINGS ${scratch_directory}/compiler_has_h5_cxx INFO_STRINGS
      REGEX "^INFO:"
259 260
    )
    string(REGEX MATCH "^INFO:([0-9]+\\.[0-9]+\\.[0-9]+)(-patch([0-9]+))?"
261
      INFO_VER "${INFO_STRINGS}"
262 263 264 265 266 267
    )
    set(${version} ${CMAKE_MATCH_1})
    if(CMAKE_MATCH_3)
      set(${version} ${HDF5_CXX_VERSION}.${CMAKE_MATCH_3})
    endif()
    set(${version} ${${version}} PARENT_SCOPE)
268

269
    if(INFO_STRINGS MATCHES "INFO:PARALLEL")
270 271 272 273
      set(${is_parallel} TRUE PARENT_SCOPE)
    else()
      set(${is_parallel} FALSE PARENT_SCOPE)
    endif()
274 275 276
  endif()
endfunction()

277
function(_HDF5_test_regular_compiler_Fortran success is_parallel)
278 279 280 281 282 283 284 285 286 287 288 289 290 291
  if(NOT ${success})
    set(scratch_directory
      ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/hdf5)
    set(test_file ${scratch_directory}/cmake_hdf5_test.f90)
    file(WRITE ${test_file}
      "program hdf5_hello\n"
      "  use hdf5\n"
      "  use h5lt\n"
      "  use h5ds\n"
      "  integer error\n"
      "  call h5open_f(error)\n"
      "  call h5close_f(error)\n"
      "end\n")
    try_compile(${success} ${scratch_directory} ${test_file})
292 293 294 295 296 297 298 299 300 301 302 303
    if(${success})
      execute_process(COMMAND ${CMAKE_Fortran_COMPILER} -showconfig
        OUTPUT_VARIABLE config_output
        ERROR_VARIABLE config_error
        RESULT_VARIABLE config_result
        )
      if(config_output MATCHES "Parallel HDF5: yes")
        set(${is_parallel} TRUE PARENT_SCOPE)
      else()
        set(${is_parallel} FALSE PARENT_SCOPE)
      endif()
    endif()
304 305
  endif()
endfunction()
306 307 308

# Invoke the HDF5 wrapper compiler.  The compiler return value is stored to the
# return_value argument, the text output is stored to the output variable.
309
macro( _HDF5_invoke_compiler language output return_value version is_parallel)
310
    set(${version})
311 312 313 314 315 316 317 318 319 320 321 322 323
    if(HDF5_USE_STATIC_LIBRARIES)
        set(lib_type_args -noshlib)
    else()
        set(lib_type_args -shlib)
    endif()
    set(scratch_dir ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/hdf5)
    if("${language}" STREQUAL "C")
        set(test_file ${scratch_dir}/cmake_hdf5_test.c)
    elseif("${language}" STREQUAL "CXX")
        set(test_file ${scratch_dir}/cmake_hdf5_test.cxx)
    elseif("${language}" STREQUAL "Fortran")
        set(test_file ${scratch_dir}/cmake_hdf5_test.f90)
    endif()
324
    exec_program( ${HDF5_${language}_COMPILER_EXECUTABLE}
325
        ARGS -show ${lib_type_args} ${test_file}
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
        OUTPUT_VARIABLE ${output}
        RETURN_VALUE ${return_value}
    )
    if(NOT ${${return_value}} EQUAL 0)
        message(STATUS
          "Unable to determine HDF5 ${language} flags from HDF5 wrapper.")
    endif()
    exec_program( ${HDF5_${language}_COMPILER_EXECUTABLE}
        ARGS -showconfig
        OUTPUT_VARIABLE config_output
        RETURN_VALUE config_return
    )
    if(NOT ${return_value} EQUAL 0)
        message( STATUS
          "Unable to determine HDF5 ${language} version from HDF5 wrapper.")
    endif()
    string(REGEX MATCH "HDF5 Version: ([a-zA-Z0-9\\.\\-]*)" version_match "${config_output}")
    if(version_match)
        string(REPLACE "HDF5 Version: " "" ${version} "${version_match}")
        string(REPLACE "-patch" "." ${version} "${${version}}")
346
    endif()
347 348 349 350 351
    if(config_output MATCHES "Parallel HDF5: yes")
      set(${is_parallel} TRUE)
    else()
      set(${is_parallel} FALSE)
    endif()
352 353 354
endmacro()

# Parse a compile line for definitions, includes, library paths, and libraries.
355
macro( _HDF5_parse_compile_line
356
    compile_line_var
357 358 359
    include_paths
    definitions
    library_paths
360 361
    libraries
    libraries_hl)
362

363
  separate_arguments(_HDF5_COMPILE_ARGS NATIVE_COMMAND "${${compile_line_var}}")
364

365 366 367 368 369 370
  foreach(arg IN LISTS _HDF5_COMPILE_ARGS)
    if("${arg}" MATCHES "^-I(.*)$")
      # include directory
      list(APPEND ${include_paths} "${CMAKE_MATCH_1}")
    elseif("${arg}" MATCHES "^-D(.*)$")
      # compile definition
371
      list(APPEND ${definitions} "-D${CMAKE_MATCH_1}")
372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
    elseif("${arg}" MATCHES "^-L(.*)$")
      # library search path
      list(APPEND ${library_paths} "${CMAKE_MATCH_1}")
    elseif("${arg}" MATCHES "^-l(hdf5.*hl.*)$")
      # library name (hl)
      list(APPEND ${libraries_hl} "${CMAKE_MATCH_1}")
    elseif("${arg}" MATCHES "^-l(.*)$")
      # library name
      list(APPEND ${libraries} "${CMAKE_MATCH_1}")
    elseif("${arg}" MATCHES "^(.:)?[/\\].*\\.(a|so|dylib|sl|lib)$")
      # library file
      if(NOT EXISTS "${arg}")
        continue()
      endif()
      get_filename_component(_HDF5_LPATH "${arg}" DIRECTORY)
      get_filename_component(_HDF5_LNAME "${arg}" NAME_WE)
      string(REGEX REPLACE "^lib" "" _HDF5_LNAME "${_HDF5_LNAME}")
      list(APPEND ${library_paths} "${_HDF5_LPATH}")
      if(_HDF5_LNAME MATCHES "hdf5.*hl")
        list(APPEND ${libraries_hl} "${_HDF5_LNAME}")
      else()
        list(APPEND ${libraries} "${_HDF5_LNAME}")
      endif()
    endif()
  endforeach()
397 398
endmacro()

399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
# Select a preferred imported configuration from a target
function(_HDF5_select_imported_config target imported_conf)
    # We will first assign the value to a local variable _imported_conf, then assign
    # it to the function argument at the end.
    get_target_property(_imported_conf ${target} MAP_IMPORTED_CONFIG_${CMAKE_BUILD_TYPE})
    if (NOT _imported_conf)
        # Get available imported configurations by examining target properties
        get_target_property(_imported_conf ${target} IMPORTED_CONFIGURATIONS)
        if(HDF5_FIND_DEBUG)
            message(STATUS "Found imported configurations: ${_imported_conf}")
        endif()
        # Find the imported configuration that we prefer.
        # We do this by making list of configurations in order of preference,
        # starting with ${CMAKE_BUILD_TYPE} and ending with the first imported_conf
        set(_preferred_confs ${CMAKE_BUILD_TYPE})
        list(GET _imported_conf 0 _fallback_conf)
        list(APPEND _preferred_confs RELWITHDEBINFO RELEASE DEBUG ${_fallback_conf})
        if(HDF5_FIND_DEBUG)
            message(STATUS "Start search through imported configurations in the following order: ${_preferred_confs}")
        endif()
        # Now find the first of these that is present in imported_conf
        cmake_policy(PUSH)
        cmake_policy(SET CMP0057 NEW) # support IN_LISTS
        foreach (_conf IN LISTS _preferred_confs)
            if (${_conf} IN_LIST _imported_conf)
               set(_imported_conf ${_conf})
               break()
            endif()
        endforeach()
        cmake_policy(POP)
    endif()
    if(HDF5_FIND_DEBUG)
        message(STATUS "Selected imported configuration: ${_imported_conf}")
    endif()
    # assign value to function argument
    set(${imported_conf} ${_imported_conf} PARENT_SCOPE)
endfunction()


438 439 440
if(NOT HDF5_ROOT)
    set(HDF5_ROOT $ENV{HDF5_ROOT})
endif()
441 442 443 444 445
if(HDF5_ROOT)
    set(_HDF5_SEARCH_OPTS NO_DEFAULT_PATH)
else()
    set(_HDF5_SEARCH_OPTS)
endif()
446

447
# Try to find HDF5 using an installed hdf5-config.cmake
448
if(NOT HDF5_FOUND AND NOT HDF5_NO_FIND_PACKAGE_CONFIG_FILE)
449 450 451 452
    find_package(HDF5 QUIET NO_MODULE
      HINTS ${HDF5_ROOT}
      ${_HDF5_SEARCH_OPTS}
      )
453
    if( HDF5_FOUND)
454 455 456
        if(HDF5_FIND_DEBUG)
            message(STATUS "Found HDF5 at ${HDF5_DIR} via NO_MODULE. Now trying to extract locations etc.")
        endif()
457
        set(HDF5_IS_PARALLEL ${HDF5_ENABLE_PARALLEL})
458 459
        set(HDF5_INCLUDE_DIRS ${HDF5_INCLUDE_DIR})
        set(HDF5_LIBRARIES)
460 461 462 463 464 465 466 467 468 469
        if (NOT TARGET hdf5 AND NOT TARGET hdf5-static AND NOT TARGET hdf5-shared)
            # Some HDF5 versions (e.g. 1.8.18) used hdf5::hdf5 etc
            set(_target_prefix "hdf5::")
        endif()
        set(HDF5_C_TARGET ${_target_prefix}hdf5)
        set(HDF5_C_HL_TARGET ${_target_prefix}hdf5_hl)
        set(HDF5_CXX_TARGET ${_target_prefix}hdf5_cpp)
        set(HDF5_CXX_HL_TARGET ${_target_prefix}hdf5_hl_cpp)
        set(HDF5_Fortran_TARGET ${_target_prefix}hdf5_fortran)
        set(HDF5_Fortran_HL_TARGET ${_target_prefix}hdf5_hl_fortran)
470
        set(HDF5_DEFINITIONS "")
471 472 473 474 475 476
        if(HDF5_USE_STATIC_LIBRARIES)
            set(_suffix "-static")
        else()
            set(_suffix "-shared")
        endif()
        foreach(_lang ${HDF5_LANGUAGE_BINDINGS})
477 478 479 480

            #Older versions of hdf5 don't have a static/shared suffix so
            #if we detect that occurrence clear the suffix
            if(_suffix AND NOT TARGET ${HDF5_${_lang}_TARGET}${_suffix})
481
              if(NOT TARGET ${HDF5_${_lang}_TARGET})
482
                #cant find this component with or without the suffix
483 484 485 486
                #so bail out, and let the following locate HDF5
                set(HDF5_FOUND FALSE)
                break()
              endif()
487 488 489
              set(_suffix "")
            endif()

490 491 492
            if(HDF5_FIND_DEBUG)
                message(STATUS "Trying to get properties of target ${HDF5_${_lang}_TARGET}${_suffix}")
            endif()
493
            # Find library for this target. Complicated as on Windows with a DLL, we need to search for the import-lib.
494 495
            _HDF5_select_imported_config(${HDF5_${_lang}_TARGET}${_suffix} _hdf5_imported_conf)
            get_target_property(_lang_location ${HDF5_${_lang}_TARGET}${_suffix} IMPORTED_IMPLIB_${_hdf5_imported_conf} )
496 497
            if (NOT _lang_location)
                # no import lib, just try LOCATION
498 499 500 501
                get_target_property(_lang_location ${HDF5_${_lang}_TARGET}${_suffix} LOCATION_${_hdf5_imported_conf})
                if (NOT _lang_location)
                    get_target_property(_lang_location ${HDF5_${_lang}_TARGET}${_suffix} LOCATION)
                endif()
502
            endif()
503
            if( _lang_location )
504
                set(HDF5_${_lang}_LIBRARY ${_lang_location})
505 506
                list(APPEND HDF5_LIBRARIES ${HDF5_${_lang}_TARGET}${_suffix})
                set(HDF5_${_lang}_LIBRARIES ${HDF5_${_lang}_TARGET}${_suffix})
507
                set(HDF5_${_lang}_FOUND True)
508 509
            endif()
            if(FIND_HL)
510
                get_target_property(__lang_hl_location ${HDF5_${_lang}_HL_TARGET}${_suffix} IMPORTED_IMPLIB_${_hdf5_imported_conf} )
511 512 513
                if (NOT _lang_hl_location)
                    get_target_property(_lang_hl_location ${HDF5_${_lang}_HL_TARGET}${_suffix} LOCATION)
                endif()
514
                if( _lang_hl_location )
515
                    set(HDF5_${_lang}_HL_LIBRARY ${_lang_hl_location})
516 517
                    list(APPEND HDF5_HL_LIBRARIES ${HDF5_${_lang}_TARGET}${_suffix})
                    set(HDF5_${_lang}_HL_LIBRARIES ${HDF5_${_lang}_TARGET}${_suffix})
518
                    set(HDF5_HL_FOUND True)
519
                endif()
520
            endif()
521
            unset( _hdf5_imported_conf)
522 523
        endforeach()
    endif()
524 525
endif()

526
if(NOT HDF5_FOUND)
527 528
  set(_HDF5_NEED_TO_SEARCH False)
  set(HDF5_COMPILER_NO_INTERROGATE True)
529
  # Only search for languages we've enabled
530
  foreach(__lang IN LISTS HDF5_LANGUAGE_BINDINGS)
531 532 533 534
    # First check to see if our regular compiler is one of wrappers
    if(__lang STREQUAL "C")
      _HDF5_test_regular_compiler_C(
        HDF5_${__lang}_COMPILER_NO_INTERROGATE
535 536
        HDF5_${__lang}_VERSION
        HDF5_${__lang}_IS_PARALLEL)
537 538 539
    elseif(__lang STREQUAL "CXX")
      _HDF5_test_regular_compiler_CXX(
        HDF5_${__lang}_COMPILER_NO_INTERROGATE
540 541
        HDF5_${__lang}_VERSION
        HDF5_${__lang}_IS_PARALLEL)
542 543
    elseif(__lang STREQUAL "Fortran")
      _HDF5_test_regular_compiler_Fortran(
544 545
        HDF5_${__lang}_COMPILER_NO_INTERROGATE
        HDF5_${__lang}_IS_PARALLEL)
546 547 548 549 550 551
    else()
      continue()
    endif()
    if(HDF5_${__lang}_COMPILER_NO_INTERROGATE)
      message(STATUS "HDF5: Using hdf5 compiler wrapper for all ${__lang} compiling")
      set(HDF5_${__lang}_FOUND True)
552 553 554
      set(HDF5_${__lang}_COMPILER_EXECUTABLE_NO_INTERROGATE
          "${CMAKE_${__lang}_COMPILER}"
          CACHE FILEPATH "HDF5 ${__lang} compiler wrapper")
555 556 557
      set(HDF5_${__lang}_DEFINITIONS)
      set(HDF5_${__lang}_INCLUDE_DIRS)
      set(HDF5_${__lang}_LIBRARIES)
558 559
      set(HDF5_${__lang}_HL_LIBRARIES)

560
      mark_as_advanced(HDF5_${__lang}_COMPILER_EXECUTABLE_NO_INTERROGATE)
561 562 563

      set(HDF5_${__lang}_FOUND True)
      set(HDF5_HL_FOUND True)
564 565 566 567 568 569
    else()
      set(HDF5_COMPILER_NO_INTERROGATE False)
      # If this language isn't using the wrapper, then try to seed the
      # search options with the wrapper
      find_program(HDF5_${__lang}_COMPILER_EXECUTABLE
        NAMES ${HDF5_${__lang}_COMPILER_NAMES} NAMES_PER_DIR
570
        HINTS ${HDF5_ROOT}
571 572
        PATH_SUFFIXES bin Bin
        DOC "HDF5 ${__lang} Wrapper compiler.  Used only to detect HDF5 compile flags."
573
        ${_HDF5_SEARCH_OPTS}
574 575 576 577 578 579
      )
      mark_as_advanced( HDF5_${__lang}_COMPILER_EXECUTABLE )
      unset(HDF5_${__lang}_COMPILER_NAMES)

      if(HDF5_${__lang}_COMPILER_EXECUTABLE)
        _HDF5_invoke_compiler(${__lang} HDF5_${__lang}_COMPILE_LINE
580
          HDF5_${__lang}_RETURN_VALUE HDF5_${__lang}_VERSION HDF5_${__lang}_IS_PARALLEL)
581 582 583 584 585 586 587
        if(HDF5_${__lang}_RETURN_VALUE EQUAL 0)
          message(STATUS "HDF5: Using hdf5 compiler wrapper to determine ${__lang} configuration")
          _HDF5_parse_compile_line( HDF5_${__lang}_COMPILE_LINE
            HDF5_${__lang}_INCLUDE_DIRS
            HDF5_${__lang}_DEFINITIONS
            HDF5_${__lang}_LIBRARY_DIRS
            HDF5_${__lang}_LIBRARY_NAMES
588
            HDF5_${__lang}_HL_LIBRARY_NAMES
589 590
          )
          set(HDF5_${__lang}_LIBRARIES)
591

592
          foreach(L IN LISTS HDF5_${__lang}_LIBRARY_NAMES)
593
            set(_HDF5_SEARCH_NAMES_LOCAL)
Ben Boeckel's avatar
Ben Boeckel committed
594
            if("x${L}" MATCHES "hdf5")
595 596
              # hdf5 library
              set(_HDF5_SEARCH_OPTS_LOCAL ${_HDF5_SEARCH_OPTS})
597 598 599 600 601 602
              if(HDF5_USE_STATIC_LIBRARIES)
                if(WIN32)
                  set(_HDF5_SEARCH_NAMES_LOCAL lib${L})
                else()
                  set(_HDF5_SEARCH_NAMES_LOCAL lib${L}.a)
                endif()
603
              endif()
604 605 606 607
            else()
              # external library
              set(_HDF5_SEARCH_OPTS_LOCAL)
            endif()
608
            find_library(HDF5_${__lang}_LIBRARY_${L}
609
              NAMES ${_HDF5_SEARCH_NAMES_LOCAL} ${L} NAMES_PER_DIR
610
              HINTS ${HDF5_${__lang}_LIBRARY_DIRS}
611 612
                    ${HDF5_ROOT}
              ${_HDF5_SEARCH_OPTS_LOCAL}
613
              )
614
            unset(_HDF5_SEARCH_OPTS_LOCAL)
615
            unset(_HDF5_SEARCH_NAMES_LOCAL)
616 617 618 619 620 621
            if(HDF5_${__lang}_LIBRARY_${L})
              list(APPEND HDF5_${__lang}_LIBRARIES ${HDF5_${__lang}_LIBRARY_${L}})
            else()
              list(APPEND HDF5_${__lang}_LIBRARIES ${L})
            endif()
          endforeach()
622 623 624
          if(FIND_HL)
            set(HDF5_${__lang}_HL_LIBRARIES)
            foreach(L IN LISTS HDF5_${__lang}_HL_LIBRARY_NAMES)
625
              set(_HDF5_SEARCH_NAMES_LOCAL)
626 627 628
              if("x${L}" MATCHES "hdf5")
                # hdf5 library
                set(_HDF5_SEARCH_OPTS_LOCAL ${_HDF5_SEARCH_OPTS})
629 630 631 632 633 634
                if(HDF5_USE_STATIC_LIBRARIES)
                  if(WIN32)
                    set(_HDF5_SEARCH_NAMES_LOCAL lib${L})
                  else()
                    set(_HDF5_SEARCH_NAMES_LOCAL lib${L}.a)
                  endif()
635
                endif()
636 637 638 639
              else()
                # external library
                set(_HDF5_SEARCH_OPTS_LOCAL)
              endif()
640
              find_library(HDF5_${__lang}_LIBRARY_${L}
641
                NAMES ${_HDF5_SEARCH_NAMES_LOCAL} ${L} NAMES_PER_DIR
642
                HINTS ${HDF5_${__lang}_LIBRARY_DIRS}
643 644
                      ${HDF5_ROOT}
                ${_HDF5_SEARCH_OPTS_LOCAL}
645
                )
646
              unset(_HDF5_SEARCH_OPTS_LOCAL)
647
              unset(_HDF5_SEARCH_NAMES_LOCAL)
648 649 650 651 652 653
              if(HDF5_${__lang}_LIBRARY_${L})
                list(APPEND HDF5_${__lang}_HL_LIBRARIES ${HDF5_${__lang}_LIBRARY_${L}})
              else()
                list(APPEND HDF5_${__lang}_HL_LIBRARIES ${L})
              endif()
            endforeach()
654
            set(HDF5_HL_FOUND True)
655
          endif()
656

657 658 659 660
          set(HDF5_${__lang}_FOUND True)
          _HDF5_remove_duplicates_from_beginning(HDF5_${__lang}_DEFINITIONS)
          _HDF5_remove_duplicates_from_beginning(HDF5_${__lang}_INCLUDE_DIRS)
          _HDF5_remove_duplicates_from_beginning(HDF5_${__lang}_LIBRARIES)
661
          _HDF5_remove_duplicates_from_beginning(HDF5_${__lang}_HL_LIBRARIES)
662 663 664 665 666 667 668 669 670 671 672 673 674 675
        else()
          set(_HDF5_NEED_TO_SEARCH True)
        endif()
      else()
        set(_HDF5_NEED_TO_SEARCH True)
      endif()
    endif()
    if(HDF5_${__lang}_VERSION)
      if(NOT HDF5_VERSION)
        set(HDF5_VERSION ${HDF5_${__lang}_VERSION})
      elseif(NOT HDF5_VERSION VERSION_EQUAL HDF5_${__lang}_VERSION)
        message(WARNING "HDF5 Version found for language ${__lang}, ${HDF5_${__lang}_VERSION} is different than previously found version ${HDF5_VERSION}")
      endif()
    endif()
676 677 678 679 680 681 682 683 684
    if(DEFINED HDF5_${__lang}_IS_PARALLEL)
      if(NOT DEFINED HDF5_IS_PARALLEL)
        set(HDF5_IS_PARALLEL ${HDF5_${__lang}_IS_PARALLEL})
      elseif(NOT HDF5_IS_PARALLEL AND HDF5_${__lang}_IS_PARALLEL)
        message(WARNING "HDF5 found for language ${__lang} is parallel but previously found language is not parallel.")
      elseif(HDF5_IS_PARALLEL AND NOT HDF5_${__lang}_IS_PARALLEL)
        message(WARNING "HDF5 found for language ${__lang} is not parallel but previously found language is parallel.")
      endif()
    endif()
685
  endforeach()
686 687
else()
  set(_HDF5_NEED_TO_SEARCH True)
688 689
endif()

690
if(NOT HDF5_FOUND AND HDF5_COMPILER_NO_INTERROGATE)
691 692 693 694
  # No arguments necessary, all languages can use the compiler wrappers
  set(HDF5_FOUND True)
  set(HDF5_METHOD "Included by compiler wrappers")
  set(HDF5_REQUIRED_VARS HDF5_METHOD)
695
elseif(NOT HDF5_FOUND AND NOT _HDF5_NEED_TO_SEARCH)
696 697 698 699
  # Compiler wrappers aren't being used by the build but were found and used
  # to determine necessary include and library flags
  set(HDF5_INCLUDE_DIRS)
  set(HDF5_LIBRARIES)
700 701
  set(HDF5_HL_LIBRARIES)
  foreach(__lang IN LISTS HDF5_LANGUAGE_BINDINGS)
702 703 704 705 706
    if(HDF5_${__lang}_FOUND)
      if(NOT HDF5_${__lang}_COMPILER_NO_INTERROGATE)
        list(APPEND HDF5_DEFINITIONS ${HDF5_${__lang}_DEFINITIONS})
        list(APPEND HDF5_INCLUDE_DIRS ${HDF5_${__lang}_INCLUDE_DIRS})
        list(APPEND HDF5_LIBRARIES ${HDF5_${__lang}_LIBRARIES})
707 708 709
        if(FIND_HL)
          list(APPEND HDF5_HL_LIBRARIES ${HDF5_${__lang}_HL_LIBRARIES})
        endif()
710 711 712 713 714 715
      endif()
    endif()
  endforeach()
  _HDF5_remove_duplicates_from_beginning(HDF5_DEFINITIONS)
  _HDF5_remove_duplicates_from_beginning(HDF5_INCLUDE_DIRS)
  _HDF5_remove_duplicates_from_beginning(HDF5_LIBRARIES)
716
  _HDF5_remove_duplicates_from_beginning(HDF5_HL_LIBRARIES)
717 718
  set(HDF5_FOUND True)
  set(HDF5_REQUIRED_VARS HDF5_LIBRARIES)
719 720 721
  if(FIND_HL)
    list(APPEND HDF5_REQUIRED_VARS HDF5_HL_LIBRARIES)
  endif()
722
endif()
723

724 725
find_program( HDF5_DIFF_EXECUTABLE
    NAMES h5diff
726
    HINTS ${HDF5_ROOT}
727
    PATH_SUFFIXES bin Bin
728
    ${_HDF5_SEARCH_OPTS}
729 730 731 732
    DOC "HDF5 file differencing tool." )
mark_as_advanced( HDF5_DIFF_EXECUTABLE )

if( NOT HDF5_FOUND )
733
    # seed the initial lists of libraries to find with items we know we need
734
    set(HDF5_C_LIBRARY_NAMES          hdf5)
735
    set(HDF5_C_HL_LIBRARY_NAMES       hdf5_hl)
736

737 738
    set(HDF5_CXX_LIBRARY_NAMES        hdf5_cpp    ${HDF5_C_LIBRARY_NAMES})
    set(HDF5_CXX_HL_LIBRARY_NAMES     hdf5_hl_cpp ${HDF5_C_HL_LIBRARY_NAMES} ${HDF5_CXX_LIBRARY_NAMES})
739

740
    set(HDF5_Fortran_LIBRARY_NAMES    hdf5_fortran   ${HDF5_C_LIBRARY_NAMES})
741
    set(HDF5_Fortran_HL_LIBRARY_NAMES hdf5hl_fortran ${HDF5_C_HL_LIBRARY_NAMES} ${HDF5_Fortran_LIBRARY_NAMES})
742

743
    foreach(__lang IN LISTS HDF5_LANGUAGE_BINDINGS)
744
        # find the HDF5 include directories
745
        if("${__lang}" STREQUAL "Fortran")
746
            set(HDF5_INCLUDE_FILENAME hdf5.mod)
747
        elseif("${__lang}" STREQUAL "CXX")
748
            set(HDF5_INCLUDE_FILENAME H5Cpp.h)
749 750 751 752
        else()
            set(HDF5_INCLUDE_FILENAME hdf5.h)
        endif()

753
        find_path(HDF5_${__lang}_INCLUDE_DIR ${HDF5_INCLUDE_FILENAME}
754
            HINTS ${HDF5_ROOT}
755 756
            PATHS $ENV{HOME}/.local/include
            PATH_SUFFIXES include Include
757
            ${_HDF5_SEARCH_OPTS}
758
        )
759
        mark_as_advanced(HDF5_${__lang}_INCLUDE_DIR)
760 761
        # set the _DIRS variable as this is what the user will normally use
        set(HDF5_${__lang}_INCLUDE_DIRS ${HDF5_${__lang}_INCLUDE_DIR})
762
        list(APPEND HDF5_INCLUDE_DIRS ${HDF5_${__lang}_INCLUDE_DIR})
763

764
        # find the HDF5 libraries
765
        foreach(LIB IN LISTS HDF5_${__lang}_LIBRARY_NAMES)
766
            if(HDF5_USE_STATIC_LIBRARIES)
767 768
                # According to bug 1643 on the CMake bug tracker, this is the
                # preferred method for searching for a static library.
769
                # See https://gitlab.kitware.com/cmake/cmake/issues/1643.  We search
770 771
                # first for the full static library name, but fall back to a
                # generic search on the name if the static search fails.
772
                set( THIS_LIBRARY_SEARCH_DEBUG
773 774 775
                    lib${LIB}d.a lib${LIB}_debug.a lib${LIB}d lib${LIB}_D lib${LIB}_debug
                    lib${LIB}d-static.a lib${LIB}_debug-static.a ${LIB}d-static ${LIB}_D-static ${LIB}_debug-static )
                set( THIS_LIBRARY_SEARCH_RELEASE lib${LIB}.a lib${LIB} lib${LIB}-static.a ${LIB}-static)
776
            else()
777
                set( THIS_LIBRARY_SEARCH_DEBUG ${LIB}d ${LIB}_D ${LIB}_debug ${LIB}d-shared ${LIB}_D-shared ${LIB}_debug-shared)
778
                set( THIS_LIBRARY_SEARCH_RELEASE ${LIB} ${LIB}-shared)
779 780 781
                if(WIN32)
                  list(APPEND HDF5_DEFINITIONS "-DH5_BUILT_AS_DYNAMIC_LIB")
                endif()
782
            endif()
783
            find_library(HDF5_${LIB}_LIBRARY_DEBUG
784
                NAMES ${THIS_LIBRARY_SEARCH_DEBUG}
785
                HINTS ${HDF5_ROOT} PATH_SUFFIXES lib Lib
786
                ${_HDF5_SEARCH_OPTS}
787
            )
788
            find_library( HDF5_${LIB}_LIBRARY_RELEASE
789
                NAMES ${THIS_LIBRARY_SEARCH_RELEASE}
790
                HINTS ${HDF5_ROOT} PATH_SUFFIXES lib Lib
791
                ${_HDF5_SEARCH_OPTS}
792
            )
793
            select_library_configurations( HDF5_${LIB} )
794
            list(APPEND HDF5_${__lang}_LIBRARIES ${HDF5_${LIB}_LIBRARY})
795 796 797 798
        endforeach()
        if(HDF5_${__lang}_LIBRARIES)
            set(HDF5_${__lang}_FOUND True)
        endif()
799

800 801
        # Append the libraries for this language binding to the list of all
        # required libraries.
802 803 804 805
        list(APPEND HDF5_LIBRARIES ${HDF5_${__lang}_LIBRARIES})

        if(FIND_HL)
            foreach(LIB IN LISTS HDF5_${__lang}_HL_LIBRARY_NAMES)
806
                if(HDF5_USE_STATIC_LIBRARIES)
807 808
                    # According to bug 1643 on the CMake bug tracker, this is the
                    # preferred method for searching for a static library.
809
                    # See https://gitlab.kitware.com/cmake/cmake/issues/1643.  We search
810 811 812
                    # first for the full static library name, but fall back to a
                    # generic search on the name if the static search fails.
                    set( THIS_LIBRARY_SEARCH_DEBUG
813 814 815
                        lib${LIB}d.a lib${LIB}_debug.a lib${LIB}d lib${LIB}_D lib${LIB}_debug
                        lib${LIB}d-static.a lib${LIB}_debug-static.a lib${LIB}d-static lib${LIB}_D-static lib${LIB}_debug-static )
                    set( THIS_LIBRARY_SEARCH_RELEASE lib${LIB}.a ${LIB} lib${LIB}-static.a lib${LIB}-static)
816
                else()
817
                    set( THIS_LIBRARY_SEARCH_DEBUG ${LIB}d ${LIB}_D ${LIB}_debug ${LIB}d-shared ${LIB}_D-shared ${LIB}_debug-shared)
818 819 820 821
                    set( THIS_LIBRARY_SEARCH_RELEASE ${LIB} ${LIB}-shared)
                endif()
                find_library(HDF5_${LIB}_LIBRARY_DEBUG
                    NAMES ${THIS_LIBRARY_SEARCH_DEBUG}
822
                    HINTS ${HDF5_ROOT} PATH_SUFFIXES lib Lib
823
                    ${_HDF5_SEARCH_OPTS}
824 825 826
                )
                find_library( HDF5_${LIB}_LIBRARY_RELEASE
                    NAMES ${THIS_LIBRARY_SEARCH_RELEASE}
827
                    HINTS ${HDF5_ROOT} PATH_SUFFIXES lib Lib
828
                    ${_HDF5_SEARCH_OPTS}
829 830 831 832 833 834 835 836 837
                )
                select_library_configurations( HDF5_${LIB} )
                list(APPEND HDF5_${__lang}_HL_LIBRARIES ${HDF5_${LIB}_LIBRARY})
            endforeach()

            # Append the libraries for this language binding to the list of all
            # required libraries.
            list(APPEND HDF5_HL_LIBRARIES ${HDF5_${__lang}_HL_LIBRARIES})
        endif()
838
    endforeach()
839 840 841
    if(FIND_HL AND HDF5_HL_LIBRARIES)
        set(HDF5_HL_FOUND True)
    endif()
842

843
    _HDF5_remove_duplicates_from_beginning(HDF5_DEFINITIONS)
844
    _HDF5_remove_duplicates_from_beginning(HDF5_INCLUDE_DIRS)
845 846
    _HDF5_remove_duplicates_from_beginning(HDF5_LIBRARIES)
    _HDF5_remove_duplicates_from_beginning(HDF5_HL_LIBRARIES)
847 848 849

    # If the HDF5 include directory was found, open H5pubconf.h to determine if
    # HDF5 was compiled with parallel IO support
850
    set( HDF5_IS_PARALLEL FALSE )
851
    set( HDF5_VERSION "" )
852
    foreach( _dir IN LISTS HDF5_INCLUDE_DIRS )
853 854 855
      foreach(_hdr "${_dir}/H5pubconf.h" "${_dir}/H5pubconf-64.h" "${_dir}/H5pubconf-32.h")
        if( EXISTS "${_hdr}" )
            file( STRINGS "${_hdr}"
856 857 858 859 860
                HDF5_HAVE_PARALLEL_DEFINE
                REGEX "HAVE_PARALLEL 1" )
            if( HDF5_HAVE_PARALLEL_DEFINE )
                set( HDF5_IS_PARALLEL TRUE )
            endif()
861 862 863 864 865 866
            unset(HDF5_HAVE_PARALLEL_DEFINE)

            file( STRINGS "${_hdr}"
                HDF5_VERSION_DEFINE
                REGEX "^[ \t]*#[ \t]*define[ \t]+H5_VERSION[ \t]+" )
            if( "${HDF5_VERSION_DEFINE}" MATCHES
867
                "H5_VERSION[ \t]+\"([0-9]+\\.[0-9]+\\.[0-9]+)(-patch([0-9]+))?\"" )
868
                set( HDF5_VERSION "${CMAKE_MATCH_1}" )
869 870 871
                if( CMAKE_MATCH_3 )
                  set( HDF5_VERSION ${HDF5_VERSION}.${CMAKE_MATCH_3})
                endif()
872 873
            endif()
            unset(HDF5_VERSION_DEFINE)
874
        endif()
875
      endforeach()
876
    endforeach()
877 878 879 880
    set( HDF5_IS_PARALLEL ${HDF5_IS_PARALLEL} CACHE BOOL
        "HDF5 library compiled with parallel IO support" )
    mark_as_advanced( HDF5_IS_PARALLEL )

881
    set(HDF5_REQUIRED_VARS HDF5_LIBRARIES HDF5_INCLUDE_DIRS)
882 883 884
    if(FIND_HL)
        list(APPEND HDF5_REQUIRED_VARS HDF5_HL_LIBRARIES)
    endif()
885 886
endif()

887 888 889 890 891 892
# For backwards compatibility we set HDF5_INCLUDE_DIR to the value of
# HDF5_INCLUDE_DIRS
if( HDF5_INCLUDE_DIRS )
  set( HDF5_INCLUDE_DIR "${HDF5_INCLUDE_DIRS}" )
endif()

893 894 895 896 897 898 899
# If HDF5_REQUIRED_VARS is empty at this point, then it's likely that
# something external is trying to explicitly pass already found
# locations
if(NOT HDF5_REQUIRED_VARS)
    set(HDF5_REQUIRED_VARS HDF5_LIBRARIES HDF5_INCLUDE_DIRS)
endif()

900 901
find_package_handle_standard_args(HDF5
    REQUIRED_VARS ${HDF5_REQUIRED_VARS}
902
    VERSION_VAR   HDF5_VERSION
903
    HANDLE_COMPONENTS
904
)
905 906

unset(_HDF5_SEARCH_OPTS)
907 908 909 910 911 912

if( HDF5_FOUND AND NOT HDF5_DIR)
  # hide HDF5_DIR for the non-advanced user to avoid confusion with
  # HDF5_DIR-NOT_FOUND while HDF5 was found.
  mark_as_advanced(HDF5_DIR)
endif()
913 914 915 916 917 918 919 920 921 922 923 924 925 926

if (HDF5_FIND_DEBUG)
  message(STATUS "HDF5_DIR: ${HDF5_DIR}")
  message(STATUS "HDF5_DEFINITIONS: ${HDF5_DEFINITIONS}")
  message(STATUS "HDF5_INCLUDE_DIRS: ${HDF5_INCLUDE_DIRS}")
  message(STATUS "HDF5_LIBRARIES: ${HDF5_LIBRARIES}")
  foreach(__lang IN LISTS HDF5_LANGUAGE_BINDINGS)
    message(STATUS "HDF5_${__lang}_DEFINITIONS: ${HDF5_${__lang}_DEFINITIONS}")
    message(STATUS "HDF5_${__lang}_INCLUDE_DIR: ${HDF5_${__lang}_INCLUDE_DIR}")
    message(STATUS "HDF5_${__lang}_INCLUDE_DIRS: ${HDF5_${__lang}_INCLUDE_DIRS}")
    message(STATUS "HDF5_${__lang}_LIBRARY: ${HDF5_${__lang}_LIBRARY}")
    message(STATUS "HDF5_${__lang}_LIBRARIES: ${HDF5_${__lang}_LIBRARIES}")
  endforeach()
endif()