diff options
Diffstat (limited to 'config/cmake/ConfigureChecks.cmake')
-rw-r--r-- | config/cmake/ConfigureChecks.cmake | 790 |
1 files changed, 790 insertions, 0 deletions
diff --git a/config/cmake/ConfigureChecks.cmake b/config/cmake/ConfigureChecks.cmake new file mode 100644 index 0000000..ae30d67 --- /dev/null +++ b/config/cmake/ConfigureChecks.cmake @@ -0,0 +1,790 @@ +#----------------------------------------------------------------------------- +# 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 (${CMAKE_ROOT}/Modules/CheckTypeSize.cmake) +INCLUDE (${CMAKE_ROOT}/Modules/CheckFortranFunctionExists.cmake) + +MESSAGE (STATUS "Configure Checks that still need to be implemented") +MESSAGE (STATUS " GetConsoleScreenBufferInfo function for Windows") + +#----------------------------------------------------------------------------- +# Always SET this for now IF we are on an OS X box +#----------------------------------------------------------------------------- +IF (APPLE) + SET (H5_AC_APPLE_UNIVERSAL_BUILD 1) +ENDIF (APPLE) + +#----------------------------------------------------------------------------- +# Option to Clear File Buffers before write --enable-clear-file-buffers +#----------------------------------------------------------------------------- +OPTION (HDF5_Enable_Clear_File_Buffers "Securely clear file buffers before writing to file" ON) +IF (HDF5_Enable_Clear_File_Buffers) + SET (H5_CLEAR_MEMORY 1) +ENDIF (HDF5_Enable_Clear_File_Buffers) + +#----------------------------------------------------------------------------- +# Option for --enable-instrument +#----------------------------------------------------------------------------- +IF (CMAKE_BUILD_TYPE MATCHES Debug) + SET (HDF5_Enable_Instrument ON) +ENDIF (CMAKE_BUILD_TYPE MATCHES Debug) +OPTION (HDF5_Enable_Instrument "Instrument The library" HDF5_Enable_Instrument) +IF (HDF5_Enable_Instrument) + SET (H5_HAVE_INSTRUMENTED_LIBRARY 1) +ENDIF (HDF5_Enable_Instrument) + +#----------------------------------------------------------------------------- +# Option for --enable-strict-format-checks +#----------------------------------------------------------------------------- +OPTION (HDF5_STRICT_FORMAT_CHECKS "Whether to perform strict file format checks" OFF) +IF (HDF5_STRICT_FORMAT_CHECKS) + SET (H5_STRICT_FORMAT_CHECKS 1) +ENDIF (HDF5_STRICT_FORMAT_CHECKS) + +#----------------------------------------------------------------------------- +# Option for --enable-metadata-trace-file +#----------------------------------------------------------------------------- +OPTION (HDF5_METADATA_TRACE_FILE "Enable metadata trace file collection" OFF) +IF (HDF5_METADATA_TRACE_FILE) + SET (H5_METADATA_TRACE_FILE 1) +ENDIF (HDF5_METADATA_TRACE_FILE) + +# ---------------------------------------------------------------------- +# Decide whether the data accuracy has higher priority during data +# conversions. If not, some hard conversions will still be prefered even +# though the data may be wrong (for example, some compilers don't +# support denormalized floating values) to maximize speed. +# +OPTION (HDF5_WANT_DATA_ACCURACY "IF data accuracy is guaranteed during data conversions" ON) +IF (HDF5_WANT_DATA_ACCURACY) + SET (H5_WANT_DATA_ACCURACY 1) +ENDIF(HDF5_WANT_DATA_ACCURACY) + +# ---------------------------------------------------------------------- +# Decide whether the presence of user's exception handling functions is +# checked and data conversion exceptions are returned. This is mainly +# for the speed optimization of hard conversions. Soft conversions can +# actually benefit little. +# +OPTION (HDF5_WANT_DCONV_EXCEPTION "exception handling functions is checked during data conversions" ON) +IF (HDF5_WANT_DCONV_EXCEPTION) + SET (H5_WANT_DCONV_EXCEPTION 1) +ENDIF (HDF5_WANT_DCONV_EXCEPTION) + +SET (LINUX_LFS 0) +SET (HDF5_EXTRA_FLAGS) +IF (CMAKE_SYSTEM MATCHES "Linux-([3-9]\\.[0-9]|2\\.[4-9])\\.") + # Linux Specific flags + ADD_DEFINITIONS (-D_POSIX_SOURCE -D_BSD_SOURCE) + OPTION (HDF5_ENABLE_LARGE_FILE "Enable support for large (64-bit) files on Linux." ON) + IF (HDF5_ENABLE_LARGE_FILE) + SET (LARGEFILE 1) + SET (HDF5_EXTRA_FLAGS -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE -D_LARGEFILE_SOURCE) + SET (CMAKE_REQUIRED_DEFINITIONS ${HDF5_EXTRA_FLAGS}) + ENDIF (HDF5_ENABLE_LARGE_FILE) +ENDIF (CMAKE_SYSTEM MATCHES "Linux-([3-9]\\.[0-9]|2\\.[4-9])\\.") +IF (LINUX_LFS) + SET (HDF5_EXTRA_FLAGS -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE -D_LARGEFILE_SOURCE) + SET (CMAKE_REQUIRED_DEFINITIONS ${HDF5_EXTRA_FLAGS}) +ENDIF (LINUX_LFS) +ADD_DEFINITIONS (${HDF5_EXTRA_FLAGS}) + +#IF (WIN32) +# SET (DEFAULT_STREAM_VFD OFF) +#ELSE (WIN32) +# SET (DEFAULT_STREAM_VFD ON) +#ENDIF (WIN32) +#OPTION (HDF5_STREAM_VFD "Compile Stream Virtual File Driver support" ${DEFAULT_STREAM_VFD}) +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) + +# TODO -------------------------------------------------------------------------- +# Should the Default Virtual File Driver be compiled? +# This is hard-coded now but option should added to match configure +# +IF (WINDOWS) + SET (H5_HAVE_WINDOWS 1) +# SET (H5_WINDOWS_USE_STDIO 0) + # ---------------------------------------------------------------------- + # Set the flag to indicate that the machine has window style pathname, + # that is, "drive-letter:\" (e.g. "C:") or "drive-letter:/" (e.g. "C:/"). + # (This flag should be _unset_ for all machines, except for Windows) + # + SET (H5_HAVE_WINDOW_PATH 1) + SET (WINDOWS_MAX_BUF (1024 * 1024 * 1024)) + SET (H5_DEFAULT_VFD H5FD_WINDOWS) +ELSE (WINDOWS) + SET (H5_DEFAULT_VFD H5FD_SEC2) +ENDIF (WINDOWS) + +# ---------------------------------------------------------------------- +# Set the flag to indicate that the machine can handle converting +# floating-point to long long values. +# (This flag should be _unset_ for all machines) +# +# SET (H5_HW_FP_TO_LLONG_NOT_WORKS 0) + +# so far we have no check for this +SET(H5_HAVE_TMPFILE 1) + +#----------------------------------------------------------------------------- +# 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 for the math library "m" +#----------------------------------------------------------------------------- +IF (WINDOWS) + SET (H5_HAVE_LIBM 1) +ELSE (WINDOWS) + CHECK_LIBRARY_EXISTS_CONCAT ("m" printf H5_HAVE_LIBM) +ENDIF (WINDOWS) +CHECK_LIBRARY_EXISTS_CONCAT ("ws2_32" printf H5_HAVE_LIBWS2_32) +CHECK_LIBRARY_EXISTS_CONCAT ("wsock32" printf H5_HAVE_LIBWSOCK32) +#CHECK_LIBRARY_EXISTS_CONCAT ("dl" dlopen H5_HAVE_LIBDL) +CHECK_LIBRARY_EXISTS_CONCAT ("ucb" gethostname H5_HAVE_LIBUCB) +CHECK_LIBRARY_EXISTS_CONCAT ("socket" connect H5_HAVE_LIBSOCKET) +CHECK_LIBRARY_EXISTS ("c" gethostbyname "" NOT_NEED_LIBNSL) + + +IF (NOT NOT_NEED_LIBNSL) + CHECK_LIBRARY_EXISTS_CONCAT ("nsl" gethostbyname H5_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 we are on Windows we know some of the answers to these tests already +#----------------------------------------------------------------------------- +IF (WINDOWS) + SET (H5_HAVE_IO_H 1) + SET (H5_HAVE_SETJMP_H 1) + SET (H5_HAVE_STDDEF_H 1) + SET (H5_HAVE_SYS_STAT_H 1) + SET (H5_HAVE_SYS_TIMEB_H 1) + SET (H5_HAVE_SYS_TYPES_H 1) + SET (H5_HAVE_WINSOCK_H 1) +ENDIF (WINDOWS) + +#----------------------------------------------------------------------------- +# Check for the existence of certain header files +#----------------------------------------------------------------------------- +CHECK_INCLUDE_FILE_CONCAT ("globus/common.h" H5_HAVE_GLOBUS_COMMON_H) +CHECK_INCLUDE_FILE_CONCAT ("io.h" H5_HAVE_IO_H) +CHECK_INCLUDE_FILE_CONCAT ("mfhdf.h" H5_HAVE_MFHDF_H) +CHECK_INCLUDE_FILE_CONCAT ("pdb.h" H5_HAVE_PDB_H) +CHECK_INCLUDE_FILE_CONCAT ("pthread.h" H5_HAVE_PTHREAD_H) +CHECK_INCLUDE_FILE_CONCAT ("setjmp.h" H5_HAVE_SETJMP_H) +CHECK_INCLUDE_FILE_CONCAT ("srbclient.h" H5_HAVE_SRBCLIENT_H) +CHECK_INCLUDE_FILE_CONCAT ("stddef.h" H5_HAVE_STDDEF_H) +CHECK_INCLUDE_FILE_CONCAT ("stdint.h" H5_HAVE_STDINT_H) +CHECK_INCLUDE_FILE_CONCAT ("string.h" H5_HAVE_STRING_H) +CHECK_INCLUDE_FILE_CONCAT ("strings.h" H5_HAVE_STRINGS_H) +CHECK_INCLUDE_FILE_CONCAT ("sys/ioctl.h" H5_HAVE_SYS_IOCTL_H) +CHECK_INCLUDE_FILE_CONCAT ("sys/proc.h" H5_HAVE_SYS_PROC_H) +CHECK_INCLUDE_FILE_CONCAT ("sys/resource.h" H5_HAVE_SYS_RESOURCE_H) +CHECK_INCLUDE_FILE_CONCAT ("sys/socket.h" H5_HAVE_SYS_SOCKET_H) +CHECK_INCLUDE_FILE_CONCAT ("sys/stat.h" H5_HAVE_SYS_STAT_H) +IF (CMAKE_SYSTEM_NAME MATCHES "OSF") + CHECK_INCLUDE_FILE_CONCAT ("sys/sysinfo.h" H5_HAVE_SYS_SYSINFO_H) +ELSE (CMAKE_SYSTEM_NAME MATCHES "OSF") + SET (H5_HAVE_SYS_SYSINFO_H "" CACHE INTERNAL "" FORCE) +ENDIF (CMAKE_SYSTEM_NAME MATCHES "OSF") +CHECK_INCLUDE_FILE_CONCAT ("sys/time.h" H5_HAVE_SYS_TIME_H) +CHECK_INCLUDE_FILE_CONCAT ("time.h" H5_HAVE_TIME_H) +CHECK_INCLUDE_FILE_CONCAT ("sys/timeb.h" H5_HAVE_SYS_TIMEB_H) +CHECK_INCLUDE_FILE_CONCAT ("sys/types.h" H5_HAVE_SYS_TYPES_H) +CHECK_INCLUDE_FILE_CONCAT ("unistd.h" H5_HAVE_UNISTD_H) +CHECK_INCLUDE_FILE_CONCAT ("stdlib.h" H5_HAVE_STDLIB_H) +CHECK_INCLUDE_FILE_CONCAT ("memory.h" H5_HAVE_MEMORY_H) +CHECK_INCLUDE_FILE_CONCAT ("dlfcn.h" H5_HAVE_DLFCN_H) +CHECK_INCLUDE_FILE_CONCAT ("features.h" H5_HAVE_FEATURES_H) +CHECK_INCLUDE_FILE_CONCAT ("inttypes.h" H5_HAVE_INTTYPES_H) +CHECK_INCLUDE_FILE_CONCAT ("winsock2.h" H5_HAVE_WINSOCK_H) +CHECK_INCLUDE_FILE_CONCAT ("netinet/in.h" H5_HAVE_NETINET_IN_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 (H5_HAVE_STDINT_H AND CMAKE_CXX_COMPILER_LOADED) + CHECK_INCLUDE_FILE_CXX ("stdint.h" H5_HAVE_STDINT_H_CXX) + IF (NOT H5_HAVE_STDINT_H_CXX) + SET (H5_HAVE_STDINT_H "" CACHE INTERNAL "Have includes HAVE_STDINT_H") + ENDIF (NOT H5_HAVE_STDINT_H_CXX) +ENDIF (H5_HAVE_STDINT_H AND CMAKE_CXX_COMPILER_LOADED) + +#----------------------------------------------------------------------------- +# Check the size in bytes of all the int and float types +#----------------------------------------------------------------------------- +MACRO (H5_CHECK_TYPE_SIZE type var) + SET (aType ${type}) + SET (aVar ${var}) +# MESSAGE (STATUS "Checking size of ${aType} and storing into ${aVar}") + CHECK_TYPE_SIZE (${aType} ${aVar}) + IF (NOT ${aVar}) + SET (${aVar} 0 CACHE INTERNAL "SizeOf for ${aType}") +# MESSAGE (STATUS "Size of ${aType} was NOT Found") + ENDIF (NOT ${aVar}) +ENDMACRO (H5_CHECK_TYPE_SIZE) + + + +H5_CHECK_TYPE_SIZE (char H5_SIZEOF_CHAR) +H5_CHECK_TYPE_SIZE (short H5_SIZEOF_SHORT) +H5_CHECK_TYPE_SIZE (int H5_SIZEOF_INT) +H5_CHECK_TYPE_SIZE (unsigned H5_SIZEOF_UNSIGNED) +IF (NOT APPLE) + H5_CHECK_TYPE_SIZE (long H5_SIZEOF_LONG) +ENDIF (NOT APPLE) +H5_CHECK_TYPE_SIZE ("long long" H5_SIZEOF_LONG_LONG) +H5_CHECK_TYPE_SIZE (__int64 H5_SIZEOF___INT64) +IF (NOT H5_SIZEOF___INT64) + SET (H5_SIZEOF___INT64 0) +ENDIF (NOT H5_SIZEOF___INT64) + +H5_CHECK_TYPE_SIZE (float H5_SIZEOF_FLOAT) +H5_CHECK_TYPE_SIZE (double H5_SIZEOF_DOUBLE) +H5_CHECK_TYPE_SIZE ("long double" H5_SIZEOF_LONG_DOUBLE) +H5_CHECK_TYPE_SIZE (int8_t H5_SIZEOF_INT8_T) +H5_CHECK_TYPE_SIZE (uint8_t H5_SIZEOF_UINT8_T) +H5_CHECK_TYPE_SIZE (int_least8_t H5_SIZEOF_INT_LEAST8_T) +H5_CHECK_TYPE_SIZE (uint_least8_t H5_SIZEOF_UINT_LEAST8_T) +H5_CHECK_TYPE_SIZE (int_fast8_t H5_SIZEOF_INT_FAST8_T) +H5_CHECK_TYPE_SIZE (uint_fast8_t H5_SIZEOF_UINT_FAST8_T) +H5_CHECK_TYPE_SIZE (int16_t H5_SIZEOF_INT16_T) +H5_CHECK_TYPE_SIZE (uint16_t H5_SIZEOF_UINT16_T) +H5_CHECK_TYPE_SIZE (int_least16_t H5_SIZEOF_INT_LEAST16_T) +H5_CHECK_TYPE_SIZE (uint_least16_t H5_SIZEOF_UINT_LEAST16_T) +H5_CHECK_TYPE_SIZE (int_fast16_t H5_SIZEOF_INT_FAST16_T) +H5_CHECK_TYPE_SIZE (uint_fast16_t H5_SIZEOF_UINT_FAST16_T) +H5_CHECK_TYPE_SIZE (int32_t H5_SIZEOF_INT32_T) +H5_CHECK_TYPE_SIZE (uint32_t H5_SIZEOF_UINT32_T) +H5_CHECK_TYPE_SIZE (int_least32_t H5_SIZEOF_INT_LEAST32_T) +H5_CHECK_TYPE_SIZE (uint_least32_t H5_SIZEOF_UINT_LEAST32_T) +H5_CHECK_TYPE_SIZE (int_fast32_t H5_SIZEOF_INT_FAST32_T) +H5_CHECK_TYPE_SIZE (uint_fast32_t H5_SIZEOF_UINT_FAST32_T) +H5_CHECK_TYPE_SIZE (int64_t H5_SIZEOF_INT64_T) +H5_CHECK_TYPE_SIZE (uint64_t H5_SIZEOF_UINT64_T) +H5_CHECK_TYPE_SIZE (int_least64_t H5_SIZEOF_INT_LEAST64_T) +H5_CHECK_TYPE_SIZE (uint_least64_t H5_SIZEOF_UINT_LEAST64_T) +H5_CHECK_TYPE_SIZE (int_fast64_t H5_SIZEOF_INT_FAST64_T) +H5_CHECK_TYPE_SIZE (uint_fast64_t H5_SIZEOF_UINT_FAST64_T) +IF (NOT APPLE) + H5_CHECK_TYPE_SIZE (size_t H5_SIZEOF_SIZE_T) + H5_CHECK_TYPE_SIZE (ssize_t H5_SIZEOF_SSIZE_T) + IF (NOT H5_SIZEOF_SSIZE_T) + SET (H5_SIZEOF_SSIZE_T 0) + ENDIF (NOT H5_SIZEOF_SSIZE_T) +ENDIF (NOT APPLE) +H5_CHECK_TYPE_SIZE (off_t H5_SIZEOF_OFF_T) +H5_CHECK_TYPE_SIZE (off64_t H5_SIZEOF_OFF64_T) +IF (NOT H5_SIZEOF_OFF64_T) + SET (H5_SIZEOF_OFF64_T 0) +ENDIF (NOT H5_SIZEOF_OFF64_T) + + +# For other tests to use the same libraries +SET (CMAKE_REQUIRED_LIBRARIES ${LINK_LIBS}) + +#----------------------------------------------------------------------------- +# Check for some functions that are used +IF (WINDOWS) + SET (H5_HAVE_STRDUP 1) + SET (H5_HAVE_SYSTEM 1) + SET (H5_HAVE_DIFFTIME 1) + SET (H5_HAVE_LONGJMP 1) + SET (H5_STDC_HEADERS 1) + SET (H5_HAVE_GETHOSTNAME 1) +ENDIF (WINDOWS) + +CHECK_FUNCTION_EXISTS (alarm H5_HAVE_ALARM) +CHECK_FUNCTION_EXISTS (fork H5_HAVE_FORK) +CHECK_FUNCTION_EXISTS (frexpf H5_HAVE_FREXPF) +CHECK_FUNCTION_EXISTS (frexpl H5_HAVE_FREXPL) + +CHECK_FUNCTION_EXISTS (gethostname H5_HAVE_GETHOSTNAME) +CHECK_FUNCTION_EXISTS (getpwuid H5_HAVE_GETPWUID) +CHECK_FUNCTION_EXISTS (getrusage H5_HAVE_GETRUSAGE) +CHECK_FUNCTION_EXISTS (lstat H5_HAVE_LSTAT) + +CHECK_FUNCTION_EXISTS (rand_r H5_HAVE_RAND_R) +CHECK_FUNCTION_EXISTS (random H5_HAVE_RANDOM) +CHECK_FUNCTION_EXISTS (setsysinfo H5_HAVE_SETSYSINFO) + +CHECK_FUNCTION_EXISTS (signal H5_HAVE_SIGNAL) +CHECK_FUNCTION_EXISTS (longjmp H5_HAVE_LONGJMP) +CHECK_FUNCTION_EXISTS (setjmp H5_HAVE_SETJMP) +CHECK_FUNCTION_EXISTS (siglongjmp H5_HAVE_SIGLONGJMP) +CHECK_FUNCTION_EXISTS (sigsetjmp H5_HAVE_SIGSETJMP) +CHECK_FUNCTION_EXISTS (sigaction H5_HAVE_SIGACTION) +CHECK_FUNCTION_EXISTS (sigprocmask H5_HAVE_SIGPROCMASK) + +CHECK_FUNCTION_EXISTS (snprintf H5_HAVE_SNPRINTF) +CHECK_FUNCTION_EXISTS (srandom H5_HAVE_SRANDOM) +CHECK_FUNCTION_EXISTS (strdup H5_HAVE_STRDUP) +CHECK_FUNCTION_EXISTS (symlink H5_HAVE_SYMLINK) +CHECK_FUNCTION_EXISTS (system H5_HAVE_SYSTEM) + +CHECK_FUNCTION_EXISTS (tmpfile H5_HAVE_TMPFILE) +CHECK_FUNCTION_EXISTS (vasprintf H5_HAVE_VASPRINTF) +CHECK_FUNCTION_EXISTS (waitpid H5_HAVE_WAITPID) + +CHECK_FUNCTION_EXISTS (vsnprintf H5_HAVE_VSNPRINTF) +CHECK_FUNCTION_EXISTS (ioctl H5_HAVE_IOCTL) +#CHECK_FUNCTION_EXISTS (gettimeofday H5_HAVE_GETTIMEOFDAY) +CHECK_FUNCTION_EXISTS (difftime H5_HAVE_DIFFTIME) +CHECK_FUNCTION_EXISTS (fseeko H5_HAVE_FSEEKO) +CHECK_FUNCTION_EXISTS (ftello H5_HAVE_FTELLO) +CHECK_FUNCTION_EXISTS (fstat64 H5_HAVE_FSTAT64) +CHECK_FUNCTION_EXISTS (stat64 H5_HAVE_STAT64) + +#----------------------------------------------------------------------------- + +#----------------------------------------------------------------------------- +# Since gettimeofday is not defined any where standard, lets look in all the +# usual places. On MSVC we are just going to use ::clock() +#----------------------------------------------------------------------------- +IF (NOT MSVC) + IF ("H5_HAVE_TIME_GETTIMEOFDAY" MATCHES "^H5_HAVE_TIME_GETTIMEOFDAY$") + TRY_COMPILE (HAVE_TIME_GETTIMEOFDAY + ${CMAKE_BINARY_DIR} + ${HDF5_RESOURCES_DIR}/GetTimeOfDayTest.cpp + COMPILE_DEFINITIONS -DTRY_TIME_H + OUTPUT_VARIABLE OUTPUT + ) + IF (HAVE_TIME_GETTIMEOFDAY STREQUAL "TRUE") + SET (H5_HAVE_TIME_GETTIMEOFDAY "1" CACHE INTERNAL "H5_HAVE_TIME_GETTIMEOFDAY") + ENDIF (HAVE_TIME_GETTIMEOFDAY STREQUAL "TRUE") + ENDIF ("H5_HAVE_TIME_GETTIMEOFDAY" MATCHES "^H5_HAVE_TIME_GETTIMEOFDAY$") + + IF ("H5_HAVE_SYS_TIME_GETTIMEOFDAY" MATCHES "^H5_HAVE_SYS_TIME_GETTIMEOFDAY$") + TRY_COMPILE (HAVE_SYS_TIME_GETTIMEOFDAY + ${CMAKE_BINARY_DIR} + ${HDF5_RESOURCES_DIR}/GetTimeOfDayTest.cpp + COMPILE_DEFINITIONS -DTRY_SYS_TIME_H + OUTPUT_VARIABLE OUTPUT + ) + IF (HAVE_SYS_TIME_GETTIMEOFDAY STREQUAL "TRUE") + SET (H5_HAVE_SYS_TIME_GETTIMEOFDAY "1" CACHE INTERNAL "H5_HAVE_SYS_TIME_GETTIMEOFDAY") + ENDIF (HAVE_SYS_TIME_GETTIMEOFDAY STREQUAL "TRUE") + ENDIF ("H5_HAVE_SYS_TIME_GETTIMEOFDAY" MATCHES "^H5_HAVE_SYS_TIME_GETTIMEOFDAY$") +ENDIF (NOT MSVC) + +IF (NOT HAVE_SYS_TIME_GETTIMEOFDAY AND NOT H5_HAVE_GETTIMEOFDAY AND NOT MSVC) + MESSAGE (STATUS "---------------------------------------------------------------") + MESSAGE (STATUS "Function 'gettimeofday()' was not found. HDF5 will use its") + MESSAGE (STATUS " own implementation.. This can happen on older versions of") + MESSAGE (STATUS " MinGW on Windows. Consider upgrading your MinGW installation") + MESSAGE (STATUS " to a newer version such as MinGW 3.12") + MESSAGE (STATUS "---------------------------------------------------------------") +ENDIF (NOT HAVE_SYS_TIME_GETTIMEOFDAY AND NOT H5_HAVE_GETTIMEOFDAY AND NOT MSVC) + + +# Check for Symbols +CHECK_SYMBOL_EXISTS (tzname "time.h" H5_HAVE_DECL_TZNAME) + +#----------------------------------------------------------------------------- +# +#----------------------------------------------------------------------------- +IF (NOT WINDOWS) + CHECK_SYMBOL_EXISTS (TIOCGWINSZ "sys/ioctl.h" H5_HAVE_TIOCGWINSZ) + CHECK_SYMBOL_EXISTS (TIOCGETD "sys/ioctl.h" H5_HAVE_TIOCGETD) +ENDIF (NOT WINDOWS) + +#----------------------------------------------------------------------------- +# Check for the Stream VFD driver +#----------------------------------------------------------------------------- +IF (HDF5_STREAM_VFD) + CHECK_INCLUDE_FILE_CONCAT ("netdb.h" H5_HAVE_NETDB_H) + CHECK_INCLUDE_FILE_CONCAT ("netinet/tcp.h" H5_HAVE_NETINET_TCP_H) + CHECK_INCLUDE_FILE_CONCAT ("sys/filio.h" H5_HAVE_SYS_FILIO_H) + SET (H5_HAVE_STREAM 1) +ENDIF (HDF5_STREAM_VFD) + + +# For other other specific tests, use this MACRO. +MACRO (HDF5_FUNCTION_TEST OTHER_TEST) + IF ("H5_${OTHER_TEST}" MATCHES "^H5_${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 + H5_HAVE_SYS_TIME_H + H5_HAVE_UNISTD_H + H5_HAVE_SYS_TYPES_H + H5_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) + + # (STATUS "Performing ${OTHER_TEST}") + TRY_COMPILE (${OTHER_TEST} + ${CMAKE_BINARY_DIR} + ${HDF5_RESOURCES_DIR}/HDF5Tests.c + CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS} + "${OTHER_TEST_ADD_LIBRARIES}" + OUTPUT_VARIABLE OUTPUT + ) + IF (${OTHER_TEST}) + SET (H5_${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 (H5_${OTHER_TEST} "" CACHE INTERNAL "Other test ${FUNCTION}") + FILE (APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log + "Performing Other Test ${OTHER_TEST} failed with the following output:\n" + "${OUTPUT}\n" + ) + ENDIF (${OTHER_TEST}) + ENDIF ("H5_${OTHER_TEST}" MATCHES "^H5_${OTHER_TEST}$") +ENDMACRO (HDF5_FUNCTION_TEST) + +#----------------------------------------------------------------------------- +# Check a bunch of other functions +#----------------------------------------------------------------------------- +IF (WINDOWS) + SET (H5_HAVE_TIMEZONE 1) + SET (H5_HAVE_FUNCTION 1) +ELSE (WINDOWS) + FOREACH (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 + GETTIMEOFDAY_GIVES_TZ + VSNPRINTF_WORKS + HAVE_C99_FUNC + HAVE_C99_DESIGNATED_INITIALIZER + CXX_HAVE_OFFSETOF + ) + HDF5_FUNCTION_TEST (${test}) + ENDFOREACH (test) +ENDIF (WINDOWS) + +#----------------------------------------------------------------------------- +# Look for 64 bit file stream capability +#----------------------------------------------------------------------------- +IF (HAVE_OFF64_T) + CHECK_FUNCTION_EXISTS (lseek64 H5_HAVE_LSEEK64) + CHECK_FUNCTION_EXISTS (fseek64 H5_HAVE_FSEEK64) +ENDIF (HAVE_OFF64_T) + +#----------------------------------------------------------------------------- +# Determine how 'inline' is used +#----------------------------------------------------------------------------- +SET (HDF5_EXTRA_TEST_DEFINITIONS INLINE_TEST_INLINE) +FOREACH (inline_test inline __inline__ __inline) + SET (INLINE_TEST_INLINE ${inline_test}) + HDF5_FUNCTION_TEST (INLINE_TEST_${inline_test}) +ENDFOREACH (inline_test) + +SET (HDF5_EXTRA_TEST_DEFINITIONS) +IF (INLINE_TEST___inline__) + SET (H5_inline __inline__) +ELSE (INLINE_TEST___inline__) + IF (INLINE_TEST___inline) + SET (H5_inline __inline) + ELSE (INLINE_TEST___inline) + IF (INLINE_TEST_inline) + SET (H5_inline inline) + ENDIF (INLINE_TEST_inline) + ENDIF (INLINE_TEST___inline) +ENDIF (INLINE_TEST___inline__) + +#----------------------------------------------------------------------------- +# Check how to print a Long Long integer +#----------------------------------------------------------------------------- +SET (H5_PRINTF_LL_WIDTH "H5_PRINTF_LL_WIDTH") +IF (H5_PRINTF_LL_WIDTH MATCHES "^H5_PRINTF_LL_WIDTH$") + SET (PRINT_LL_FOUND 0) + MESSAGE (STATUS "Checking for appropriate format for 64 bit long:") + FOREACH (HDF5_PRINTF_LL l64 l L q I64 ll) + SET (CURRENT_TEST_DEFINITIONS "-DPRINTF_LL_WIDTH=${HDF5_PRINTF_LL}") + IF (H5_SIZEOF_LONG_LONG) + SET (CURRENT_TEST_DEFINITIONS "${CURRENT_TEST_DEFINITIONS} -DHAVE_LONG_LONG") + ENDIF (H5_SIZEOF_LONG_LONG) + TRY_RUN (HDF5_PRINTF_LL_TEST_RUN HDF5_PRINTF_LL_TEST_COMPILE + ${HDF5_BINARY_DIR}/CMake + ${HDF5_RESOURCES_DIR}/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 (H5_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) + FILE (APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log + "Test H5_PRINTF_LL_WIDTH for ${HDF5_PRINTF_LL} failed with the following output:\n ${OUTPUT}\n" + ) + 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 ${H5_PRINTF_LL_WIDTH}") + ELSE (PRINT_LL_FOUND) + MESSAGE (STATUS "Checking for apropriate format for 64 bit long: not found") + SET (H5_PRINTF_LL_WIDTH "\"unknown\"" CACHE INTERNAL + "Width for printf for type `long long' or `__int64', us. `ll" + ) + ENDIF (PRINT_LL_FOUND) +ENDIF (H5_PRINTF_LL_WIDTH MATCHES "^H5_PRINTF_LL_WIDTH$") + +# ---------------------------------------------------------------------- +# Set the flag to indicate that the machine can handle converting +# denormalized floating-point values. +# (This flag should be set for all machines, except for the Crays, where +# the cache value is set in it's config file) +# +SET (H5_CONVERT_DENORMAL_FLOAT 1) + +#----------------------------------------------------------------------------- +# Are we going to use HSIZE_T +#----------------------------------------------------------------------------- +IF (HDF5_ENABLE_HSIZET) + SET (H5_HAVE_LARGE_HSIZET 1) +ENDIF (HDF5_ENABLE_HSIZET) +IF (CYGWIN) + SET (H5_HAVE_LSEEK64 0) +ENDIF (CYGWIN) + +#----------------------------------------------------------------------------- +# Macro to determine the various conversion capabilities +#----------------------------------------------------------------------------- +MACRO (H5ConversionTests TEST msg) + IF ("${TEST}" MATCHES "^${TEST}$") + # MESSAGE (STATUS "===> ${TEST}") + TRY_RUN (${TEST}_RUN ${TEST}_COMPILE + ${HDF5_BINARY_DIR}/CMake + ${HDF5_RESOURCES_DIR}/ConversionTests.c + CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=-D${TEST}_TEST + OUTPUT_VARIABLE OUTPUT + ) + IF (${TEST}_COMPILE) + IF (${TEST}_RUN MATCHES 0) + SET (${TEST} 1 CACHE INTERNAL ${msg}) + MESSAGE(STATUS "${msg}... yes") + ELSE (${TEST}_RUN MATCHES 0) + SET (${TEST} "" CACHE INTERNAL ${msg}) + MESSAGE (STATUS "${msg}... no") + FILE (APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log + "Test ${TEST} Run failed with the following output and exit code:\n ${OUTPUT}\n" + ) + ENDIF (${TEST}_RUN MATCHES 0) + ELSE (${TEST}_COMPILE ) + SET (${TEST} "" CACHE INTERNAL ${msg}) + MESSAGE (STATUS "${msg}... no") + FILE (APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log + "Test ${TEST} Compile failed with the following output:\n ${OUTPUT}\n" + ) + ENDIF (${TEST}_COMPILE) + + ENDIF("${TEST}" MATCHES "^${TEST}$") +ENDMACRO (H5ConversionTests) + +#----------------------------------------------------------------------------- +# Macro to make some of the conversion tests easier to write/read +#----------------------------------------------------------------------------- +MACRO (H5MiscConversionTest VAR TEST msg) + IF ("${TEST}" MATCHES "^${TEST}$") + IF (${VAR}) + SET (${TEST} 1 CACHE INTERNAL ${msg}) + MESSAGE (STATUS "${msg}... yes") + ELSE (${VAR}) + SET (${TEST} "" CACHE INTERNAL ${msg}) + MESSAGE (STATUS "${msg}... no") + ENDIF (${VAR}) + ENDIF ("${TEST}" MATCHES "^${TEST}$") +ENDMACRO (H5MiscConversionTest) + +#----------------------------------------------------------------------------- +# Check various conversion capabilities +#----------------------------------------------------------------------------- + +# ----------------------------------------------------------------------- +# Set flag to indicate that the machine can handle conversion from +# long double to integers accurately. This flag should be set "yes" for +# all machines except all SGIs. For SGIs, some conversions are +# incorrect and its cache value is set "no" in its config/irix6.x and +# irix5.x. +# +H5MiscConversionTest (H5_SIZEOF_LONG_DOUBLE H5_LDOUBLE_TO_INTEGER_ACCURATE "checking IF converting from long double to integers is accurate") +# ----------------------------------------------------------------------- +# Set flag to indicate that the machine can do conversion from +# long double to integers regardless of accuracy. This flag should be +# set "yes" for all machines except HP-UX 11.00. For HP-UX 11.00, the +# compiler has 'floating exception' when converting 'long double' to all +# integers except 'unsigned long long'. Other HP-UX systems are unknown +# yet. (1/8/05 - SLU) +# +H5ConversionTests (H5_LDOUBLE_TO_INTEGER_WORKS "Checking IF converting from long double to integers works") +# ----------------------------------------------------------------------- +# Set flag to indicate that the machine can handle conversion from +# integers to long double. (This flag should be set "yes" for all +# machines except all SGIs, where some conversions are +# incorrect and its cache value is set "no" in its config/irix6.x and +# irix5.x) +# +H5MiscConversionTest (H5_SIZEOF_LONG_DOUBLE H5_INTEGER_TO_LDOUBLE_ACCURATE "checking IF accurately converting from integers to long double") +# ---------------------------------------------------------------------- +# Set the flag to indicate that the machine can accurately convert +# 'unsigned long' to 'float' values. +# (This flag should be set for all machines, except for Pathscale compiler +# on Sandia's Linux machine where the compiler interprets 'unsigned long' +# values as negative when the first bit of 'unsigned long' is on during +# the conversion to float.) +# +H5ConversionTests (H5_ULONG_TO_FLOAT_ACCURATE "Checking IF accurately converting unsigned long to float values") +# ---------------------------------------------------------------------- +# Set the flag to indicate that the machine can accurately convert +# 'unsigned (long) long' values to 'float' and 'double' values. +# (This flag should be set for all machines, except for the SGIs, where +# the cache value is set in the config/irix6.x config file) and Solaris +# 64-bit machines, where the short program below tests if round-up is +# correctly handled. +# +H5ConversionTests (H5_ULONG_TO_FP_BOTTOM_BIT_ACCURATE "Checking IF accurately converting unsigned long long to floating-point values") +# ---------------------------------------------------------------------- +# Set the flag to indicate that the machine can accurately convert +# 'float' or 'double' to 'unsigned long long' values. +# (This flag should be set for all machines, except for PGI compiler +# where round-up happens when the fraction of float-point value is greater +# than 0.5. +# +H5ConversionTests (H5_FP_TO_ULLONG_ACCURATE "Checking IF accurately roundup converting floating-point to unsigned long long values" ) +# ---------------------------------------------------------------------- +# Set the flag to indicate that the machine can accurately convert +# 'float', 'double' or 'long double' to 'unsigned long long' values. +# (This flag should be set for all machines, except for HP-UX machines +# where the maximal number for unsigned long long is 0x7fffffffffffffff +# during conversion. +# +H5ConversionTests (H5_FP_TO_ULLONG_RIGHT_MAXIMUM "Checking IF right maximum converting floating-point to unsigned long long values" ) +# ---------------------------------------------------------------------- +# Set the flag to indicate that the machine can accurately convert +# 'long double' to 'unsigned int' values. (This flag should be set for +# all machines, except for some Intel compilers on some Linux.) +# +H5ConversionTests (H5_LDOUBLE_TO_UINT_ACCURATE "Checking IF correctly converting long double to unsigned int values") +# ---------------------------------------------------------------------- +# Set the flag to indicate that the machine can _compile_ +# 'unsigned long long' to 'float' and 'double' typecasts. +# (This flag should be set for all machines.) +# +IF (H5_ULLONG_TO_FP_CAST_WORKS MATCHES ^H5_ULLONG_TO_FP_CAST_WORKS$) + SET (H5_ULLONG_TO_FP_CAST_WORKS 1 CACHE INTERNAL "Checking IF compiling unsigned long long to floating-point typecasts work") + MESSAGE (STATUS "Checking IF compiling unsigned long long to floating-point typecasts work... yes") +ENDIF (H5_ULLONG_TO_FP_CAST_WORKS MATCHES ^H5_ULLONG_TO_FP_CAST_WORKS$) +# ---------------------------------------------------------------------- +# Set the flag to indicate that the machine can _compile_ +# 'long long' to 'float' and 'double' typecasts. +# (This flag should be set for all machines.) +# +IF (H5_LLONG_TO_FP_CAST_WORKS MATCHES ^H5_LLONG_TO_FP_CAST_WORKS$) + SET (H5_LLONG_TO_FP_CAST_WORKS 1 CACHE INTERNAL "Checking IF compiling long long to floating-point typecasts work") + MESSAGE (STATUS "Checking IF compiling long long to floating-point typecasts work... yes") +ENDIF (H5_LLONG_TO_FP_CAST_WORKS MATCHES ^H5_LLONG_TO_FP_CAST_WORKS$) +# ---------------------------------------------------------------------- +# Set the flag to indicate that the machine can convert from +# 'unsigned long long' to 'long double' without precision loss. +# (This flag should be set for all machines, except for FreeBSD(sleipnir) +# where the last 2 bytes of mantissa are lost when compiler tries to do +# the conversion, and Cygwin where compiler doesn't do rounding correctly.) +# +H5ConversionTests (H5_ULLONG_TO_LDOUBLE_PRECISION "Checking IF converting unsigned long long to long double with precision") +# ---------------------------------------------------------------------- +# Set the flag to indicate that the machine can handle overflow converting +# all floating-point to all integer types. +# (This flag should be set for all machines, except for Cray X1 where +# floating exception is generated when the floating-point value is greater +# than the maximal integer value). +# +H5ConversionTests (H5_FP_TO_INTEGER_OVERFLOW_WORKS "Checking IF overflows normally converting floating-point to integer values") +# ---------------------------------------------------------------------- +# Set the flag to indicate that the machine can accurately convert +# 'long double' to '(unsigned) long long' values. (This flag should be set for +# all machines, except for Mac OS 10.4 and SGI IRIX64 6.5. When the bit sequence +# of long double is 0x4351ccf385ebc8a0bfcc2a3c..., the values of (unsigned)long long +# start to go wrong on these two machines. Adjusting it higher to +# 0x4351ccf385ebc8a0dfcc... or 0x4351ccf385ebc8a0ffcc... will make the converted +# values wildly wrong. This test detects this wrong behavior and disable the test. +# +H5ConversionTests (H5_LDOUBLE_TO_LLONG_ACCURATE "Checking IF correctly converting long double to (unsigned) long long values") +# ---------------------------------------------------------------------- +# Set the flag to indicate that the machine can accurately convert +# '(unsigned) long long' to 'long double' values. (This flag should be set for +# all machines, except for Mac OS 10.4, when the bit sequences are 003fff..., +# 007fff..., 00ffff..., 01ffff..., ..., 7fffff..., the converted values are twice +# as big as they should be. +# +H5ConversionTests (H5_LLONG_TO_LDOUBLE_CORRECT "Checking IF correctly converting (unsigned) long long to long double values") +H5ConversionTests (H5_NO_ALIGNMENT_RESTRICTIONS "Checking IF alignment restrictions are strictly enforced") + +#----------------------------------------------------------------------------- +# These tests need to be manually SET for windows since there is currently +# something not quite correct with the actual test implementation. This affects +# the 'dt_arith' test and most likely lots of other code +# ---------------------------------------------------------------------------- +IF (WINDOWS) + SET (H5_FP_TO_ULLONG_RIGHT_MAXIMUM "" CACHE INTERNAL "") +ENDIF (WINDOWS) |