PROJECT(VTKHDF5 C)

CMAKE_MINIMUM_REQUIRED(VERSION 2.0)
IF(COMMAND CMAKE_POLICY)
  CMAKE_POLICY(SET CMP0003 NEW)
ENDIF(COMMAND CMAKE_POLICY)

MARK_AS_ADVANCED(HDF5_STREAM_VFD HDF5_ENABLE_HSIZET HDF5_ENABLE_LINUX_LFS HDF5_ENABLE_PARALLEL)

INCLUDE_REGULAR_EXPRESSION("^.*\\.[ch]$")

# EXPORT() will be in cmake 2.6, add an empty macro so older cmake versions still work
IF(NOT COMMAND EXPORT)
  MACRO(EXPORT)
  ENDMACRO(EXPORT)
ENDIF(NOT COMMAND EXPORT)

# Add configured headers to this var to have them installed
SET(hinToInstall)
# Add configured cmake files to this var to have them installed
SET(cmakeinToInstall)

SET(LIBRARY_OUTPUT_PATH ${VTKHDF5_BINARY_DIR}/bin CACHE PATH
  "Single output directory for building all libraries.")
SET(EXECUTABLE_OUTPUT_PATH ${VTKHDF5_BINARY_DIR}/bin CACHE PATH
  "Single output directory for building all executables.")
MARK_AS_ADVANCED(LIBRARY_OUTPUT_PATH EXECUTABLE_OUTPUT_PATH)

# Choose install directories.
IF(NOT VTKHDF5_INSTALL_LIB_DIR)
  SET(VTKHDF5_INSTALL_LIB_DIR /lib)
ENDIF(NOT VTKHDF5_INSTALL_LIB_DIR)

# Let parent project set VTKHDF5_INSTALL_NO_DEVELOPMENT or
# VTKHDF5_INSTALL_NO_RUNTIME to remove components from the installation.
SET(VTKHDF5_INSTALL_NO_LIBRARIES)
IF(BUILD_SHARED_LIBS)
  IF(VTKHDF5_INSTALL_NO_RUNTIME AND VTKHDF5_INSTALL_NO_DEVELOPMENT)
    SET(VTKHDF5_INSTALL_NO_LIBRARIES 1)
  ENDIF(VTKHDF5_INSTALL_NO_RUNTIME AND VTKHDF5_INSTALL_NO_DEVELOPMENT)
ELSE(BUILD_SHARED_LIBS)
  IF(VTKHDF5_INSTALL_NO_DEVELOPMENT)
    SET(VTKHDF5_INSTALL_NO_LIBRARIES 1)
  ENDIF(VTKHDF5_INSTALL_NO_DEVELOPMENT)
ENDIF(BUILD_SHARED_LIBS)

SET(CMAKE_C_FLAGS "${CMAKE_ANSI_CFLAGS} ${CMAKE_C_FLAGS}")

IF(NOT HDF5_ZLIB_HEADER)
  SET(HDF5_ZLIB_HEADER "zlib.h")
ENDIF(NOT HDF5_ZLIB_HEADER)
CONFIGURE_FILE(
  ${VTKHDF5_SOURCE_DIR}/hdf5_zlib.h.in
  ${VTKHDF5_BINARY_DIR}/hdf5_zlib.h
  IMMEDIATE)
SET(hinToInstall "${hinToInstall};${VTKHDF5_BINARY_DIR}/hdf5_zlib.h")

# Block warnings unless we are instructed to allow them.
# SET(HDF5_WARNINGS_ALLOW 1)
IF(NOT HDF5_WARNINGS_ALLOW)
  # MSVC uses /w to suppress warnings.  It also complains if another
  # warning level is given, so remove it.
  IF(MSVC)
    SET(HDF5_WARNINGS_BLOCKED 1)
    STRING(REGEX REPLACE "(^| )([/-])W[0-9]( |$)" " "
      CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
    SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /w")
  ENDIF(MSVC)

  # Borland uses -w- to suppress warnings.
  IF(BORLAND)
    SET(HDF5_WARNINGS_BLOCKED 1)
    SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w-")
  ENDIF(BORLAND)

  # Most compilers use -w to suppress warnings.
  IF(NOT HDF5_WARNINGS_BLOCKED)
    SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w")
  ENDIF(NOT HDF5_WARNINGS_BLOCKED)
ENDIF(NOT HDF5_WARNINGS_ALLOW)

SET(PACKAGE_VERSION "\"1.6.5\"")
SET(PACKAGE_TARNAME "\"hdf5\"")
SET(PACKAGE_NAME "\"HDF5\"")
SET(PACKAGE_STRING "\"HDF5 1.6.5\"")
SET(PACKAGE_BUGREPORT "\"hdfhelp@ncsa.uiuc.edu\"")

SET(LINUX_LFS 0)
IF(CMAKE_SYSTEM MATCHES "Linux-([3-9]\\.[0-9]|2\\.[4-9])\\.")
  OPTION(HDF5_ENABLE_LINUX_LFS
    "Enable support for large (64-bit) files on Linux." ON)
  IF(HDF5_ENABLE_LINUX_LFS)
    SET(LINUX_LFS 1)
  ENDIF(HDF5_ENABLE_LINUX_LFS)
ENDIF(CMAKE_SYSTEM MATCHES "Linux-([3-9]\\.[0-9]|2\\.[4-9])\\.")
SET(HDF5_EXTRA_FLAGS)
IF(LINUX_LFS)
  SET(HDF5_EXTRA_FLAGS
    -D_FILE_OFFSET_BITS=64
    -D_LARGEFILE64_SOURCE
    -D_LARGEFILE_SOURCE)
ENDIF(LINUX_LFS)
ADD_DEFINITIONS(${HDF5_EXTRA_FLAGS})

OPTION(HDF5_STREAM_VFD "Compile Stream Virtual File Driver support" ON)
OPTION(HDF5_ENABLE_HSIZET "Enable datasets larger than memory" ON)
IF(VTK_USE_MPI)
  OPTION(HDF5_ENABLE_PARALLEL "Enable parallel build (uses MPI)" OFF)
ENDIF(VTK_USE_MPI)

# Include all the necessary files for macros
INCLUDE (CheckFunctionExists)
INCLUDE (CheckIncludeFile)
INCLUDE (CheckIncludeFileCXX)
INCLUDE (CheckIncludeFiles)
INCLUDE (CheckLibraryExists)
INCLUDE (CheckSymbolExists)
INCLUDE (CheckTypeSize)

# This macro checks if the symbol exists in the library and if it
# does, it appends library to the list.
SET(LINK_LIBS "")
MACRO(CHECK_LIBRARY_EXISTS_CONCAT LIBRARY SYMBOL VARIABLE)
  CHECK_LIBRARY_EXISTS("${LIBRARY};${LINK_LIBS}" ${SYMBOL} "" ${VARIABLE})
  IF(${VARIABLE})
    SET(LINK_LIBS ${LINK_LIBS} ${LIBRARY})
  ENDIF(${VARIABLE})
ENDMACRO(CHECK_LIBRARY_EXISTS_CONCAT)

CHECK_LIBRARY_EXISTS_CONCAT("m" printf HAVE_LIBM)
CHECK_LIBRARY_EXISTS_CONCAT("ws2_32" printf HAVE_LIBWS2_32)
CHECK_LIBRARY_EXISTS_CONCAT("wsock32" printf HAVE_LIBWSOCK32)
#CHECK_LIBRARY_EXISTS_CONCAT("dl"     dlopen       HAVE_LIBDL)
CHECK_LIBRARY_EXISTS_CONCAT("ucb"    gethostname  HAVE_LIBUCB)
CHECK_LIBRARY_EXISTS_CONCAT("socket" connect      HAVE_LIBSOCKET)
CHECK_LIBRARY_EXISTS("c" gethostbyname "" NOT_NEED_LIBNSL)

IF(NOT NOT_NEED_LIBNSL)
  CHECK_LIBRARY_EXISTS_CONCAT("nsl"    gethostbyname  HAVE_LIBNSL)
ENDIF(NOT NOT_NEED_LIBNSL)


SET(USE_INCLUDES "")
# Check if header file exists and add it to the list.
MACRO(CHECK_INCLUDE_FILE_CONCAT FILE VARIABLE)
  CHECK_INCLUDE_FILES("${USE_INCLUDES};${FILE}" ${VARIABLE})
  IF(${VARIABLE})
    SET(USE_INCLUDES ${USE_INCLUDES} ${FILE})
  ENDIF(${VARIABLE})
ENDMACRO(CHECK_INCLUDE_FILE_CONCAT)

CHECK_INCLUDE_FILE_CONCAT("globus/common.h" HAVE_GLOBUS_COMMON_H)
CHECK_INCLUDE_FILE_CONCAT("io.h" HAVE_IO_H)
CHECK_INCLUDE_FILE_CONCAT("mfhdf.h" HAVE_MFHDF_H)
CHECK_INCLUDE_FILE_CONCAT("pdb.h" HAVE_PDB_H)
CHECK_INCLUDE_FILE_CONCAT("pthread.h" HAVE_PTHREAD_H)
CHECK_INCLUDE_FILE_CONCAT("setjmp.h" HAVE_SETJMP_H)
CHECK_INCLUDE_FILE_CONCAT("srbclient.h" HAVE_SRBCLIENT_H)
CHECK_INCLUDE_FILE_CONCAT("stddef.h" HAVE_STDDEF_H)
CHECK_INCLUDE_FILE_CONCAT("stdint.h" HAVE_STDINT_H)
CHECK_INCLUDE_FILE_CONCAT("string.h" HAVE_STRING_H)
CHECK_INCLUDE_FILE_CONCAT("strings.h" HAVE_STRINGS_H)
CHECK_INCLUDE_FILE_CONCAT("sys/ioctl.h" HAVE_SYS_IOCTL_H)
CHECK_INCLUDE_FILE_CONCAT("sys/proc.h" HAVE_SYS_PROC_H)
CHECK_INCLUDE_FILE_CONCAT("sys/resource.h" HAVE_SYS_RESOURCE_H)
CHECK_INCLUDE_FILE_CONCAT("sys/socket.h" HAVE_SYS_SOCKET_H)
CHECK_INCLUDE_FILE_CONCAT("sys/stat.h" HAVE_SYS_STAT_H)
IF(CMAKE_SYSTEM_NAME MATCHES "OSF")
  CHECK_INCLUDE_FILE_CONCAT("sys/sysinfo.h" HAVE_SYS_SYSINFO_H)
ELSE(CMAKE_SYSTEM_NAME MATCHES "OSF")
  SET(HAVE_SYS_SYSINFO_H "" CACHE INTERNAL "" FORCE)
ENDIF(CMAKE_SYSTEM_NAME MATCHES "OSF")
CHECK_INCLUDE_FILE_CONCAT("sys/time.h" HAVE_SYS_TIME_H)
CHECK_INCLUDE_FILE_CONCAT("sys/timeb.h" HAVE_SYS_TIMEB_H)
CHECK_INCLUDE_FILE_CONCAT("sys/types.h" HAVE_SYS_TYPES_H)
CHECK_INCLUDE_FILE_CONCAT("unistd.h" HAVE_UNISTD_H)
CHECK_INCLUDE_FILE_CONCAT("stdlib.h" HAVE_STDLIB_H)
CHECK_INCLUDE_FILE_CONCAT("memory.h" HAVE_MEMORY_H)
CHECK_INCLUDE_FILE_CONCAT("dlfcn.h" HAVE_DLFCN_H)
CHECK_INCLUDE_FILE_CONCAT("features.h" HAVE_FEATURES_H)
CHECK_INCLUDE_FILE_CONCAT("inttypes.h" HAVE_INTTYPES_H)
CHECK_INCLUDE_FILE_CONCAT("winsock.h" HAVE_WINSOCK_H)

# if the c compiler found stdint, check the C++ as well. On some systems this
# file will be found by C but not C++, only do this test if the C++ compiler
# has been initialized (e.g. the project also includes some c++)
IF (HAVE_STDINT_H AND CMAKE_CXX_COMPILER_LOADED)
  CHECK_INCLUDE_FILE_CXX("stdint.h" HAVE_STDINT_H_CXX)
  IF (NOT HAVE_STDINT_H_CXX)
    SET (HAVE_STDINT_H "" CACHE INTERNAL "Have includes HAVE_STDINT_H")
  ENDIF (NOT HAVE_STDINT_H_CXX)
ENDIF (HAVE_STDINT_H AND CMAKE_CXX_COMPILER_LOADED)

IF(HDF5_ZLIB_INCLUDE_DIRS OR VTK_ZLIB_LIBRARIES)
  SET(HAVE_ZLIB_H 1)
ELSE(HDF5_ZLIB_INCLUDE_DIRS OR VTK_ZLIB_LIBRARIES)
  CHECK_INCLUDE_FILE_CONCAT("zlib.h" HAVE_ZLIB_H)
ENDIF(HDF5_ZLIB_INCLUDE_DIRS OR VTK_ZLIB_LIBRARIES)

CHECK_TYPE_SIZE(char           SIZEOF_CHAR)
CHECK_TYPE_SIZE(short          SIZEOF_SHORT)
CHECK_TYPE_SIZE(int            SIZEOF_INT)
CHECK_TYPE_SIZE(long           SIZEOF_LONG)
CHECK_TYPE_SIZE(float          SIZEOF_FLOAT)
CHECK_TYPE_SIZE(double         SIZEOF_DOUBLE)
CHECK_TYPE_SIZE("long double"  SIZEOF_LONG_DOUBLE)
CHECK_TYPE_SIZE(int8_t         SIZEOF_INT8_T)
CHECK_TYPE_SIZE(uint8_t        SIZEOF_UINT8_T)
CHECK_TYPE_SIZE(int_least8_t   SIZEOF_INT_LEAST8_T)
CHECK_TYPE_SIZE(uint_least8_t  SIZEOF_UINT_LEAST8_T)
CHECK_TYPE_SIZE(int_fast8_t    SIZEOF_INT_FAST8_T)
CHECK_TYPE_SIZE(uint_fast8_t   SIZEOF_UINT_FAST8_T)
CHECK_TYPE_SIZE(int16_t        SIZEOF_INT16_T)
CHECK_TYPE_SIZE(uint16_t       SIZEOF_UINT16_T)
CHECK_TYPE_SIZE(int_least16_t  SIZEOF_INT_LEAST16_T)
CHECK_TYPE_SIZE(uint_least16_t SIZEOF_UINT_LEAST16_T)
CHECK_TYPE_SIZE(int_fast16_t   SIZEOF_INT_FAST16_T)
CHECK_TYPE_SIZE(uint_fast16_t  SIZEOF_UINT_FAST16_T)
CHECK_TYPE_SIZE(int32_t        SIZEOF_INT32_T)
CHECK_TYPE_SIZE(uint32_t       SIZEOF_UINT32_T)
CHECK_TYPE_SIZE(int_least32_t  SIZEOF_INT_LEAST32_T)
CHECK_TYPE_SIZE(uint_least32_t SIZEOF_UINT_LEAST32_T)
CHECK_TYPE_SIZE(int_fast32_t   SIZEOF_INT_FAST32_T)
CHECK_TYPE_SIZE(uint_fast32_t  SIZEOF_UINT_FAST32_T)
CHECK_TYPE_SIZE(int64_t        SIZEOF_INT64_T)
CHECK_TYPE_SIZE(uint64_t       SIZEOF_UINT64_T)
CHECK_TYPE_SIZE(jdshkjfhdks    SIZEOF_JDSHKJFHDKS)
CHECK_TYPE_SIZE(int_least64_t  SIZEOF_INT_LEAST64_T)
CHECK_TYPE_SIZE(uint_least64_t SIZEOF_UINT_LEAST64_T)
CHECK_TYPE_SIZE(int_fast64_t   SIZEOF_INT_FAST64_T)
CHECK_TYPE_SIZE(uint_fast64_t  SIZEOF_UINT_FAST64_T)
CHECK_TYPE_SIZE(size_t         SIZEOF_SIZE_T)
CHECK_TYPE_SIZE(ssize_t        SIZEOF_SSIZE_T)
CHECK_TYPE_SIZE(off_t          SIZEOF_OFF_T)
CHECK_TYPE_SIZE(__int64        SIZEOF___INT64)
CHECK_TYPE_SIZE("long long"    SIZEOF_LONG_LONG)

# For other tests to use the same libraries
SET(CMAKE_REQUIRED_LIBRARIES ${LINK_LIBS})

# Check for some functions that are used
CHECK_FUNCTION_EXISTS(strdup            HAVE_STRDUP)
CHECK_FUNCTION_EXISTS(snprintf          HAVE_SNPRINTF)
CHECK_FUNCTION_EXISTS(system            HAVE_SYSTEM)
CHECK_FUNCTION_EXISTS(vsnprintf         HAVE_VSNPRINTF)
CHECK_FUNCTION_EXISTS(waitpid           HAVE_WAITPID)
CHECK_FUNCTION_EXISTS(signal            HAVE_SIGNAL)
CHECK_FUNCTION_EXISTS(ioctl             HAVE_IOCTL)
CHECK_FUNCTION_EXISTS(sigaction         HAVE_SIGACTION)
CHECK_FUNCTION_EXISTS(getpwuid          HAVE_GETPWUID)
CHECK_FUNCTION_EXISTS(getrusage         HAVE_GETRUSAGE)
CHECK_FUNCTION_EXISTS(gettimeofday      HAVE_GETTIMEOFDAY)
CHECK_FUNCTION_EXISTS(longjmp           HAVE_LONGJMP)
CHECK_FUNCTION_EXISTS(fork              HAVE_FORK)
CHECK_FUNCTION_EXISTS(difftime          HAVE_DIFFTIME)
CHECK_FUNCTION_EXISTS(gethostname       HAVE_GETHOSTNAME)
CHECK_FUNCTION_EXISTS(sigaction         HAVE_SIGACTION)
CHECK_FUNCTION_EXISTS(frexpf            HAVE_FREXPF)
CHECK_FUNCTION_EXISTS(frexpl            HAVE_FREXPL)

CHECK_SYMBOL_EXISTS(TIOCGWINSZ "sys/ioctl.h" HAVE_TIOCGWINSZ)
CHECK_SYMBOL_EXISTS(TIOCGETD   "sys/ioctl.h" HAVE_TIOCGETD)
# e.g. IBM BlueGene/L doesn't have SO_REUSEADDR, because "setsockopt is not needed for
# BlueGene/L applications" according to the BlueGene/L Application Development handbook
CHECK_SYMBOL_EXISTS(SO_REUSEADDR "sys/types.h;sys/socket.h" HAVE_SO_REUSEADDR)

IF(HDF5_STREAM_VFD)
  CHECK_INCLUDE_FILE_CONCAT("netdb.h" HAVE_NETDB_H)
  CHECK_INCLUDE_FILE_CONCAT("netinet/tcp.h" HAVE_NETINET_TCP_H)
  CHECK_INCLUDE_FILE_CONCAT("sys/filio.h" HAVE_SYS_FILIO_H)
  SET(H5_HAVE_STREAM 1)
ENDIF(HDF5_STREAM_VFD)

# Cray Xt3/Catamount doesn't support IP networking
IF(CMAKE_SYSTEM MATCHES Catamount)
  SET(H5_HAVE_STREAM 0)
ENDIF(CMAKE_SYSTEM MATCHES Catamount)


# For other other specific tests, use this macro.
MACRO(OTHER_INTERNAL_TEST OTHER_TEST)
  IF("${OTHER_TEST}" MATCHES "^${OTHER_TEST}$")
    SET(MACRO_CHECK_FUNCTION_DEFINITIONS
      "-D${OTHER_TEST} ${CMAKE_REQUIRED_FLAGS}")
    SET(OTHER_TEST_ADD_LIBRARIES)
    IF(CMAKE_REQUIRED_LIBRARIES)
      SET(OTHER_TEST_ADD_LIBRARIES
        "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
    ENDIF(CMAKE_REQUIRED_LIBRARIES)
    FOREACH(def ${HDF5_EXTRA_TEST_DEFINITIONS})
      SET(MACRO_CHECK_FUNCTION_DEFINITIONS
        "${MACRO_CHECK_FUNCTION_DEFINITIONS} -D${def}=${${def}}")
    ENDFOREACH(def)

    FOREACH(def
        HAVE_SYS_TIME_H
        HAVE_UNISTD_H
        HAVE_SYS_TYPES_H
        HAVE_SYS_SOCKET_H)
      IF("${def}")
        SET(MACRO_CHECK_FUNCTION_DEFINITIONS
          "${MACRO_CHECK_FUNCTION_DEFINITIONS} -D${def}")
      ENDIF("${def}")
    ENDFOREACH(def)
    IF(LINUX_LFS)
    #don't be tempted to put this all in one multiline string macro will fail
      SET(MACRO_CHECK_FUNCTION_DEFINITIONS
        "${MACRO_CHECK_FUNCTION_DEFINITIONS} -D_FILE_OFFSET_BITS=64")
      SET(MACRO_CHECK_FUNCTION_DEFINITIONS
        "${MACRO_CHECK_FUNCTION_DEFINITIONS} -D_LARGEFILE64_SOURCE")
      SET(MACRO_CHECK_FUNCTION_DEFINITIONS
        "${MACRO_CHECK_FUNCTION_DEFINITIONS} -D_LARGEFILE_SOURCE")
    ENDIF(LINUX_LFS)

    MESSAGE(STATUS "Performing Other Test ${OTHER_TEST}")
    TRY_COMPILE(${OTHER_TEST}
      ${CMAKE_BINARY_DIR}
      ${VTKHDF5_SOURCE_DIR}/CMake/HDF5Tests.c
      CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
      "${OTHER_TEST_ADD_LIBRARIES}"
      OUTPUT_VARIABLE OUTPUT)
    IF(${OTHER_TEST})
      SET(${OTHER_TEST} 1 CACHE INTERNAL "Other test ${FUNCTION}")
      MESSAGE(STATUS "Performing Other Test ${OTHER_TEST} - Success")
    ELSE(${OTHER_TEST})
      MESSAGE(STATUS "Performing Other Test ${OTHER_TEST} - Failed")
      SET(${OTHER_TEST} "" CACHE INTERNAL "Other test ${FUNCTION}")
      WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
        "Performing Other Test ${OTHER_TEST} failed with the following "
        "output:\n${OUTPUT}\n" APPEND)
    ENDIF(${OTHER_TEST})
  ENDIF("${OTHER_TEST}" MATCHES "^${OTHER_TEST}$")
ENDMACRO(OTHER_INTERNAL_TEST)

# Do curl specific tests
FOREACH(CURL_TEST
    TIME_WITH_SYS_TIME
    STDC_HEADERS
    HAVE_TM_ZONE
    HAVE_STRUCT_TM_TM_ZONE
    HAVE_ATTRIBUTE
    HAVE_FUNCTION
    HAVE_TM_GMTOFF
    HAVE_TIMEZONE
    HAVE_STRUCT_TIMEZONE
    HAVE_STAT_ST_BLOCKS
    HAVE_FUNCTION
    SYSTEM_SCOPE_THREADS
    HAVE_SOCKLEN_T
    DEV_T_IS_SCALAR
    HAVE_OFF64_T
    )
  OTHER_INTERNAL_TEST(${CURL_TEST})
ENDFOREACH(CURL_TEST)

IF(HAVE_OFF64_T)
  CHECK_FUNCTION_EXISTS(lseek64           HAVE_LSEEK64)
  CHECK_FUNCTION_EXISTS(fseek64           HAVE_FSEEK64)
ENDIF(HAVE_OFF64_T)

SET(HDF5_EXTRA_TEST_DEFINITIONS INLINE_TEST_INLINE)
FOREACH(inline_test inline __inline__ __inline)
  SET(INLINE_TEST_INLINE ${inline_test})
  OTHER_INTERNAL_TEST(INLINE_TEST_${inline_test})
ENDFOREACH(inline_test)
SET(HDF5_EXTRA_TEST_DEFINITIONS)
IF(INLINE_TEST___inline__)
  SET(inline __inline__)
ELSE(INLINE_TEST___inline__)
  IF(INLINE_TEST___inline)
    SET(inline __inline)
  ELSE(INLINE_TEST___inline)
    IF(INLINE_TEST_inline)
      SET(inline inline)
    ENDIF(INLINE_TEST_inline)
  ENDIF(INLINE_TEST___inline)
ENDIF(INLINE_TEST___inline__)


IF(PRINTF_LL_WIDTH MATCHES "^PRINTF_LL_WIDTH$")
  MESSAGE(STATUS "Checking for apropriate format for 64 bit long:")
  SET(CURRENT_TEST_DEFINITIONS "-DPRINTF_LL_WIDTH")
  IF(SIZEOF_LONG_LONG)
    SET(CURRENT_TEST_DEFINITIONS "${CURRENT_TEST_DEFINITIONS} -DHAVE_LONG_LONG")
  ENDIF(SIZEOF_LONG_LONG)
  TRY_RUN(HDF5_PRINTF_LL_TEST_RUN HDF5_PRINTF_LL_TEST_COMPILE
    ${VTKHDF5_BINARY_DIR}/CMake
    ${VTKHDF5_SOURCE_DIR}/CMake/HDF5Tests.c
    CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${CURRENT_TEST_DEFINITIONS}
    OUTPUT_VARIABLE OUTPUT)

  IF   (HDF5_PRINTF_LL_TEST_COMPILE)
    IF   (HDF5_PRINTF_LL_TEST_RUN MATCHES 0)
      STRING(REGEX REPLACE ".*PRINTF_LL_WIDTH=\\[(.+)\\].*" "\\1" PRINTF_LL_WIDTH "${OUTPUT}" )
      SET(PRINTF_LL_WIDTH "\"${PRINTF_LL_WIDTH}\"" CACHE INTERNAL "Width for printf for type `long long' or `__int64', us. `ll")
    ELSE (HDF5_PRINTF_LL_TEST_RUN MATCHES 0)
      SET(PRINTF_LL_WIDTH "\"unknown\"" CACHE INTERNAL "Width for printf for type `long long' or `__int64', us. `ll")
    ENDIF(HDF5_PRINTF_LL_TEST_RUN MATCHES 0)
  ELSE (HDF5_PRINTF_LL_TEST_COMPILE)
    WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
      "Test PRINTF_LL_WIDTH failed with the following output:\n${OUTPUT}\n" APPEND)
  ENDIF(HDF5_PRINTF_LL_TEST_COMPILE)
  MESSAGE(STATUS "Checking for apropriate format for 64 bit long: ${PRINTF_LL_WIDTH}")
ENDIF(PRINTF_LL_WIDTH MATCHES "^PRINTF_LL_WIDTH$")

# Some things that are always true
SET(CONVERT_DENORMAL_FLOAT 1)
SET(HAVE_LIBZ 1)
SET(HAVE_FILTER_DEFLATE 1)
SET(HAVE_FILTER_FLETCHER32 1)
SET(HAVE_FILTER_SHUFFLE 1)
IF(HDF5_ENABLE_HSIZET)
  SET(HAVE_LARGE_HSIZET 1)
ENDIF(HDF5_ENABLE_HSIZET)

IF(HDF5_ENABLE_PARALLEL AND VTK_USE_MPI)
  SET(HAVE_PARALLEL 1)
  FIND_PACKAGE(MPI)
  ADD_DEFINITIONS("-DMPICH_IGNORE_CXX_SEEK") 
  INCLUDE_DIRECTORIES(${MPI_INCLUDE_PATH})
  SET(HDF5_MPI_INCLUDE_PATH ${MPI_INCLUDE_PATH})
ENDIF (HDF5_ENABLE_PARALLEL AND VTK_USE_MPI)

IF(CYGWIN)
  SET(HAVE_LSEEK64 0)
ENDIF(CYGWIN)

SET(common_SRCS
H5.c          H5FDmpio.c      H5HP.c        H5Pfapl.c      H5Tconv.c
H5A.c         H5FDmpiposix.c  H5I.c         H5Pfcpl.c      H5Tcset.c
H5AC.c        H5FDmulti.c     H5MF.c        H5Ptest.c      H5Tenum.c
H5B.c         H5FDsec2.c      H5MM.c        H5R.c          H5Tfields.c
H5C.c         H5FDsrb.c       H5O.c         H5RC.c         H5Tfixed.c
H5D.c         H5FDstdio.c     H5Oattr.c     H5RS.c         H5Tfloat.c
H5Dcompact.c  H5FDstream.c    H5Obogus.c    H5S.c          H5Tnative.c
H5Dcontig.c   H5FL.c          H5Ocont.c     H5SL.c         H5Toffset.c
H5Defl.c      H5FO.c          H5Odtype.c    H5ST.c         H5Topaque.c
H5Dio.c       H5FS.c          H5Oefl.c      H5Sall.c       H5Torder.c
H5Distore.c   H5Fdbg.c        H5Ofill.c     H5Shyper.c     H5Tpad.c
H5Dmpio.c     H5Fmount.c      H5Olayout.c   H5Smpio.c      H5Tprecis.c
H5Dselect.c   H5Fsfile.c      H5Omtime.c    H5Snone.c      H5Tstrpad.c
H5Dtest.c     H5Fsuper.c      H5Oname.c     H5Spoint.c     H5Tvlen.c
H5E.c         H5G.c           H5Onull.c     H5Sselect.c    H5V.c
H5F.c         H5Gent.c        H5Opline.c    H5Stest.c      H5Z.c
H5FD.c        H5Gnode.c       H5Osdspace.c  H5T.c          H5Zdeflate.c
H5FDcore.c    H5Gstab.c       H5Oshared.c   H5TS.c         H5Zfletcher32.c
H5FDfamily.c  H5HG.c          H5Ostab.c     H5Tarray.c     H5Zshuffle.c
H5FDgass.c    H5HGdbg.c       H5P.c         H5Tbit.c       H5Zszip.c
H5FDlog.c     H5HL.c          H5Pdcpl.c     H5Tcommit.c
H5FDmpi.c     H5HLdbg.c       H5Pdxpl.c     H5Tcompound.c
  )

IF(APPLE)
  SET_SOURCE_FILES_PROPERTIES(
  H5.c
  H5D.c
  H5E.c
  PROPERTIES
  COMPILE_FLAGS -fno-common)
ENDIF(APPLE)

INCLUDE_DIRECTORIES(${VTKHDF5_SOURCE_DIR}
  ${VTKHDF5_BINARY_DIR})

# This variable is used in H5pubconf to detect shared libraries.
IF(BUILD_SHARED_LIBS)
  SET(VTKHDF5_BUILD_SHARED_LIBS 1)
ELSE(BUILD_SHARED_LIBS)
  SET(VTKHDF5_BUILD_SHARED_LIBS 0)
ENDIF(BUILD_SHARED_LIBS)

SET(CONFIG_FILE_EXT h.cmake)

CONFIGURE_FILE(
  ${VTKHDF5_SOURCE_DIR}/H5config.${CONFIG_FILE_EXT}.in
  ${VTKHDF5_BINARY_DIR}/H5config.h 
  IMMEDIATE)
SET(hinToInstall "${hinToInstall};${VTKHDF5_BINARY_DIR}/H5config.h")

FILE(READ "${VTKHDF5_BINARY_DIR}/H5config.h" HDF5_PUBLIC_CONFIG)
STRING(REGEX REPLACE "#define " "#define H5_" HDF5_PUBLIC_CONFIG ${HDF5_PUBLIC_CONFIG})
STRING(REGEX REPLACE "#undef " "#undef H5_" HDF5_PUBLIC_CONFIG ${HDF5_PUBLIC_CONFIG})

CONFIGURE_FILE(
  ${VTKHDF5_SOURCE_DIR}/H5pubconf.${CONFIG_FILE_EXT}.in
  ${VTKHDF5_BINARY_DIR}/H5pubconf.h
  IMMEDIATE)
SET(hinToInstall "${hinToInstall};${VTKHDF5_BINARY_DIR}/H5pubconf.h")

SET(common_SRCS ${common_SRCS} ${VTKHDF5_BINARY_DIR}/H5Tinit.c)
SET_SOURCE_FILES_PROPERTIES (${VTKHDF5_BINARY_DIR}/H5Tinit.c GENERATED)

IF(HDF5_ZLIB_INCLUDE_DIRS)
  INCLUDE_DIRECTORIES(${HDF5_ZLIB_INCLUDE_DIRS})
ENDIF(HDF5_ZLIB_INCLUDE_DIRS)
IF(VTK_ZLIB_INCLUDE_DIRS)
  INCLUDE_DIRECTORIES(${VTK_ZLIB_INCLUDE_DIRS})
ENDIF(VTK_ZLIB_INCLUDE_DIRS)

ADD_LIBRARY(vtkhdf5 ${common_SRCS})
TARGET_LINK_LIBRARIES(vtkhdf5 ${LINK_LIBS})

IF(HDF5_ENABLE_PARALLEL AND VTK_USE_MPI)
  IF (MPI_LIBRARY) 
    SET(HDFMPI_LIBS "${MPI_LIBRARY}")   
  ELSE (MPI_LIBRARY)   
    MESSAGE("Could not find the required MPI libraries")
  ENDIF (MPI_LIBRARY)   
  IF (MPI_EXTRA_LIBRARY)   
    SET(HDFMPI_LIBS ${HDFMPI_LIBS} "${MPI_EXTRA_LIBRARY}")   
  ENDIF (MPI_EXTRA_LIBRARY) 
  TARGET_LINK_LIBRARIES(vtkhdf5 ${HDFMPI_LIBS})
ENDIF (HDF5_ENABLE_PARALLEL AND VTK_USE_MPI)

IF(XDMF_ZLIB_LIBRARIES)
  TARGET_LINK_LIBRARIES(vtkhdf5 ${XDMF_ZLIB_LIBRARIES})
ENDIF(XDMF_ZLIB_LIBRARIES)

IF(VTK_ZLIB_LIBRARIES)
  TARGET_LINK_LIBRARIES(vtkhdf5 ${VTK_ZLIB_LIBRARIES})
ENDIF(VTK_ZLIB_LIBRARIES)

IF(NOT VTKHDF5_INSTALL_NO_LIBRARIES)
  INSTALL(TARGETS vtkhdf5
    RUNTIME DESTINATION ${PV_INSTALL_BIN_DIR} COMPONENT Runtime
    LIBRARY DESTINATION ${PV_INSTALL_LIB_DIR} COMPONENT Runtime
    ARCHIVE DESTINATION ${PV_INSTALL_LIB_DIR} COMPONENT Development)
ENDIF(NOT VTKHDF5_INSTALL_NO_LIBRARIES)

IF(NOT CMAKE_CROSSCOMPILING)
  ADD_EXECUTABLE(H5detect H5detect.c)
  TARGET_LINK_LIBRARIES(H5detect ${LINK_LIBS})
  EXPORT(TARGETS H5detect FILE ${EXPORT_EXECUTABLES_FILE} NAMESPACE "${EXPORT_EXECUTABLES_NAMESPACE}" APPEND)
  IF(COMPILE_TOOLS_TARGET)
    ADD_DEPENDENCIES(${COMPILE_TOOLS_TARGET} H5detect)
  ENDIF(COMPILE_TOOLS_TARGET)
ENDIF(NOT CMAKE_CROSSCOMPILING)

IF(CMAKE_CROSSCOMPILING)
  SET(CMD H5detect)
ELSE(CMAKE_CROSSCOMPILING)
  GET_TARGET_PROPERTY(CMD H5detect LOCATION)
ENDIF(CMAKE_CROSSCOMPILING)

ADD_CUSTOM_COMMAND(
  OUTPUT ${VTKHDF5_BINARY_DIR}/H5Tinit.c
  COMMAND ${CMD}
  ARGS > ${VTKHDF5_BINARY_DIR}/H5Tinit.c
  DEPENDS H5detect
  )

CONFIGURE_FILE(
  ${VTKHDF5_SOURCE_DIR}/HDF5Config.cmake.in
  ${VTKHDF5_BINARY_DIR}/HDF5Config.cmake 
  @ONLY
  IMMEDIATE)
SET(cmakeinToInstall "${cmakeinToInstall};${VTKHDF5_BINARY_DIR}/HDF5Config.cmake")

CONFIGURE_FILE(
  ${VTKHDF5_SOURCE_DIR}/CTestCustom.ctest.in
  ${VTKHDF5_BINARY_DIR}/CTestCustom.ctest 
  @ONLY
  IMMEDIATE)

# Development files install
IF (NOT PV_INSTALL_NO_DEVELOPMENT)
  FILE(GLOB hToInstall
      RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
      "*.h")
  INSTALL(
      FILES ${hToInstall}
      DESTINATION "${PV_INSTALL_INCLUDE_DIR}/hdf5"
      COMPONENT Development)
  INSTALL(
      FILES ${hinToInstall}
      DESTINATION "${PV_INSTALL_INCLUDE_DIR}/hdf5"
      COMPONENT Development)
  INSTALL(
      FILES ${cmakeinToInstall} 
      DESTINATION ${PV_INSTALL_LIB_DIR}
      COMPONENT Development)
ENDIF (NOT PV_INSTALL_NO_DEVELOPMENT)
