CMAKE_MINIMUM_REQUIRED(VERSION 1.8)
PROJECT(VTKHDF5 C)
INCLUDE_REGULAR_EXPRESSION("^.*\\.[ch]$")

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)

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

SET(PACKAGE_VERSION "\"1.6.2\"")
SET(PACKAGE_TARNAME "\"hdf5\"")
SET(PACKAGE_NAME "\"HDF5\"")
SET(PACKAGE_STRING "\"HDF5 1.6.2\"")
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)

SET(WINDOWS)
IF(WIN32)
  IF(NOT UNIX)
    #SET(WINDOWS 1)
  ENDIF(NOT UNIX)
ENDIF(WIN32)

IF(WINDOWS)
  SET(ssize_t long)
  SET(SIZEOF_SIZE_T 4)
  SET(SIZEOF_SSIZE_T 4)
  SET(HAVE_LARGE_HSIZET 1)
ENDIF(WINDOWS)

# Include all the necessary files for macros
INCLUDE (${CMAKE_ROOT}/Modules/CheckFunctionExists.cmake)
INCLUDE (${CMAKE_ROOT}/Modules/CheckIncludeFile.cmake)
INCLUDE (${CMAKE_ROOT}/Modules/CheckIncludeFileCXX.cmake)
INCLUDE (${CMAKE_ROOT}/Modules/CheckIncludeFiles.cmake)
INCLUDE (${CMAKE_ROOT}/Modules/CheckLibraryExists.cmake)
INCLUDE (${CMAKE_ROOT}/Modules/CheckSymbolExists.cmake)
INCLUDE (${VTKHDF5_SOURCE_DIR}/CMake/CheckTypeSize.cmake)

# 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)

IF(WINDOWS)
  SET(HAVE_LIBM 1)
ELSE(WINDOWS)
  CHECK_LIBRARY_EXISTS_CONCAT("m" printf HAVE_LIBM)
ENDIF(WINDOWS)
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)

IF(WINDOWS)
  SET(HAVE_IO_H 1)
  SET(HAVE_SETJMP_H 1)
  SET(HAVE_STDDEF_H 1)
  SET(HAVE_SYS_STAT_H 1)
  SET(HAVE_SYS_TIMEB_H 1)
  SET(HAVE_SYS_TYPES_H 1)
  SET(HAVE_WINSOCK_H 1)
ELSE(WINDOWS)
  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)
ENDIF(WINDOWS)

# 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(XDMF_ZLIB_INCLUDE_DIRS OR VTK_ZLIB_LIBRARIES)
  SET(HAVE_ZLIB_H 1)
ELSE(XDMF_ZLIB_INCLUDE_DIRS OR VTK_ZLIB_LIBRARIES)
  CHECK_INCLUDE_FILE_CONCAT("zlib.h" HAVE_ZLIB_H)
ENDIF(XDMF_ZLIB_INCLUDE_DIRS OR VTK_ZLIB_LIBRARIES)

IF(WINDOWS)
  SET(HAVE_SIZEOF_CHAR TRUE)
  SET(HAVE_SIZEOF_DOUBLE TRUE)
  SET(HAVE_SIZEOF_FLOAT TRUE)
  SET(HAVE_SIZEOF_INT TRUE)
  SET(HAVE_SIZEOF_LONG TRUE)
  SET(HAVE_SIZEOF_LONG_DOUBLE TRUE)
  SET(HAVE_SIZEOF_OFF_T TRUE)
  SET(HAVE_SIZEOF_SHORT TRUE)
  SET(HAVE_SIZEOF_SIZE_T TRUE)
  SET(HAVE_SIZEOF___INT64 TRUE)
  SET(SIZEOF_CHAR 1)
  SET(SIZEOF_DOUBLE 8)
  SET(SIZEOF_FLOAT 4)
  SET(SIZEOF_INT 4)
  SET(SIZEOF_LONG 4)
  SET(SIZEOF_LONG_DOUBLE 8)
  SET(SIZEOF_OFF_T 4)
  SET(SIZEOF_SHORT 2)
  SET(SIZEOF_SIZE_T 4)
  SET(SIZEOF___INT64 8)
ELSE(WINDOWS)
  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)
ENDIF(WINDOWS)

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

# Check for some functions that are used
IF(WINDOWS)
  SET(HAVE_STRDUP 1)
  SET(HAVE_SYSTEM 1)
  SET(HAVE_DIFFTIME 1)
  SET(HAVE_LONGJMP 1)
ELSE(WINDOWS)
  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)
ENDIF(WINDOWS)

IF(NOT WINDOWS)
  CHECK_SYMBOL_EXISTS(TIOCGWINSZ "sys/ioctl.h" HAVE_TIOCGWINSZ)
  CHECK_SYMBOL_EXISTS(TIOCGETD   "sys/ioctl.h" HAVE_TIOCGETD)
ENDIF(NOT WINDOWS)

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(HAVE_STREAM 1)
ENDIF(HDF5_STREAM_VFD)


# 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)
      SET(MACRO_CHECK_FUNCTION_DEFINITIONS
        "${MACRO_CHECK_FUNCTION_DEFINITIONS} -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE -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}/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
IF(WINDOWS)
  SET(HAVE_TIMEZONE 1)
  SET(HAVE_FUNCTION 1)
ELSE(WINDOWS)
  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_ATTRIBUTE
      HAVE_FUNCTION
      SYSTEM_SCOPE_THREADS
      HAVE_SOCKLEN_T
      DEV_T_IS_SCALAR
      HAVE_OFF64_T
      )
    OTHER_INTERNAL_TEST(${CURL_TEST})
  ENDFOREACH(CURL_TEST)
ENDIF(WINDOWS)

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(WINDOWS)
  SET(PRINTF_LL_WIDTH "unknown")
ELSE(WINDOWS)
  IF(PRINTF_LL_WIDTH MATCHES "^PRINTF_LL_WIDTH$")
    SET(PRINT_LL_FOUND 0)
    MESSAGE(STATUS "Checking for apropriate format for 64 bit long:")
    FOREACH(HDF5_PRINTF_LL l64 l L q ll)
      SET(CURRENT_TEST_DEFINITIONS "-DPRINTF_LL_WIDTH=${HDF5_PRINTF_LL}")
      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)
          SET(PRINTF_LL_WIDTH "\"${HDF5_PRINTF_LL}\"" CACHE INTERNAL
            "Width for printf for type `long long' or `__int64', us. `ll")
          SET(PRINT_LL_FOUND 1)
        ELSE(HDF5_PRINTF_LL_TEST_RUN MATCHES 0)
          #MESSAGE("Width with ${HDF5_PRINTF_LL} failed with result: ${HDF5_PRINTF_LL_TEST_RUN}")
        ENDIF(HDF5_PRINTF_LL_TEST_RUN MATCHES 0)
      ELSE(HDF5_PRINTF_LL_TEST_COMPILE)
        WRITE_FILE(${CMAKE_BINARY_DIR}/CMakeError.log
          "Test PRINTF_LL_WIDTH for ${HDF5_PRINTF_LL} failed with the following output:\n"
          "${OUTPUT}\n" APPEND)
      ENDIF(HDF5_PRINTF_LL_TEST_COMPILE)
    ENDFOREACH(HDF5_PRINTF_LL)
    IF(PRINT_LL_FOUND)
      MESSAGE(STATUS "Checking for apropriate format for 64 bit long: found ${PRINTF_LL_WIDTH}")
    ELSE(PRINT_LL_FOUND)
      MESSAGE(STATUS "Checking for apropriate format for 64 bit long: not found")
      SET(PRINTF_LL_WIDTH "\"unknown\"" CACHE INTERNAL
        "Width for printf for type `long long' or `__int64', us. `ll")
    ENDIF(PRINT_LL_FOUND)
  ENDIF(PRINTF_LL_WIDTH MATCHES "^PRINTF_LL_WIDTH$")
ENDIF(WINDOWS)

# 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(CYGWIN)
  SET(HAVE_LSEEK64 0)
ENDIF(CYGWIN)

SET(common_SRCS
  H5.c            H5FL.c        H5Oattr.c     H5RS.c         H5Tfixed.c
  H5A.c           H5FO.c        H5Obogus.c    H5S.c          H5Tfloat.c
  H5AC.c          H5FP.c        H5Ocont.c     H5ST.c         H5Tnative.c
  H5B.c           H5FPclient.c  H5Odtype.c    H5Sall.c       H5Toffset.c
  H5D.c           H5FPserver.c  H5Oefl.c      H5Shyper.c     H5Topaque.c
  H5Dio.c         H5FS.c        H5Ofill.c     H5Smpio.c      H5Torder.c
  H5E.c           H5Fcompact.c  H5Olayout.c   H5Snone.c      H5Tpad.c
  H5F.c           H5Fcontig.c   H5Omtime.c    H5Spoint.c     H5Tprecis.c
  H5FD.c          H5Fistore.c   H5Oname.c     H5Sselect.c    H5Tstrpad.c
  H5FDcore.c      H5Fseq.c      H5Onull.c     H5Stest.c      H5Tvlen.c
  H5FDfamily.c    H5G.c         H5Opline.c    H5T.c          H5V.c
  H5FDfphdf5.c    H5Gent.c      H5Osdspace.c  H5TB.c         H5Z.c
  H5FDgass.c      H5Gnode.c     H5Oshared.c   H5TS.c         H5Zdeflate.c
  H5FDlog.c       H5Gstab.c     H5Ostab.c     H5Tarray.c     H5Zfletcher32.c
  H5FDmpio.c      H5HG.c        H5P.c         H5Tbit.c       H5Zshuffle.c
  H5FDmpiposix.c  H5HL.c        H5Pdcpl.c     H5Tcommit.c    H5Zszip.c
  H5FDmulti.c     H5HP.c        H5Pdxpl.c     H5Tcompound.c
  H5FDsec2.c      H5I.c         H5Pfapl.c     H5Tconv.c
  H5FDsrb.c       H5MF.c        H5Pfcpl.c     H5Tcset.c
  H5FDstdio.c     H5MM.c        H5Ptest.c     H5Tenum.c
  H5FDstream.c    H5O.c         H5R.c         H5Tfields.c

  )

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)
IF(WINDOWS)
  #SET(CONFIG_FILE_EXT WIN32.h)
ENDIF(WINDOWS)

CONFIGURE_FILE(${VTKHDF5_SOURCE_DIR}/H5config.${CONFIG_FILE_EXT}.in
  ${VTKHDF5_BINARY_DIR}/H5config.h IMMEDIATE)

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)

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(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(BUILD_SHARED_LIBS AND VTKHDF5_INSTALL_LIB_DIR)
  INSTALL_TARGETS(${VTKHDF5_INSTALL_LIB_DIR} vtkhdf5)
ENDIF(BUILD_SHARED_LIBS AND VTKHDF5_INSTALL_LIB_DIR)

SET(EXE_EXT "")
IF(WIN32)
  SET(EXE_EXT ".exe")
ENDIF(WIN32)

SET(MAKE_SYSTEM)
IF(CMAKE_BUILD_TOOL MATCHES "make")
  SET(MAKE_SYSTEM 1)
ENDIF(CMAKE_BUILD_TOOL MATCHES "make")

SET(CFG_INIT "/${CMAKE_CFG_INTDIR}")
IF(MAKE_SYSTEM OR UNIX)
  SET(CFG_INIT "")
ENDIF(MAKE_SYSTEM OR UNIX)
SET(CMD ${EXECUTABLE_OUTPUT_PATH}${CFG_INIT}/H5detect${EXE_EXT})

ADD_EXECUTABLE(H5detect H5detect.c)
TARGET_LINK_LIBRARIES(H5detect ${LINK_LIBS})
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)

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

MARK_AS_ADVANCED(HDF5_STREAM_VFD HDF5_ENABLE_HSIZET HDF5_ENABLE_LINUX_LFS)
