mirror of
https://github.com/HDFGroup/hdf5.git
synced 2024-11-27 02:10:55 +08:00
[svn-r27337] cmake configure test for Fortran
This commit is contained in:
Scot Breitenfeld
parent
29bdf0884a
commit
b3b02d5112
461
config/cmake/HDF5UseFortran.cmake
Normal file
461
config/cmake/HDF5UseFortran.cmake
Normal file
@ -0,0 +1,461 @@
|
||||
|
||||
#
|
||||
# This file provides functions for HDF5 specific Fortran support.
|
||||
#
|
||||
#-------------------------------------------------------------------------------
|
||||
ENABLE_LANGUAGE (Fortran)
|
||||
|
||||
# The provided CMake Fortran macros don't provide a general compile/run function
|
||||
# so this one is used.
|
||||
#-----------------------------------------------------------------------------
|
||||
MACRO (FORTRAN_RUN FUNCTION CODE RUN_RESULT_VAR COMPILE_RESULT_VAR RETURN)
|
||||
# MSB CHECK WHY THIS CHECK?
|
||||
# if (NOT DEFINED ${RUN_RESULT_VAR})
|
||||
message (STATUS "Detecting Fortran ${FUNCTION}")
|
||||
if (CMAKE_REQUIRED_LIBRARIES)
|
||||
set (CHECK_FUNCTION_EXISTS_ADD_LIBRARIES
|
||||
"-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
|
||||
else (CMAKE_REQUIRED_LIBRARIES)
|
||||
set (CHECK_FUNCTION_EXISTS_ADD_LIBRARIES)
|
||||
endif (CMAKE_REQUIRED_LIBRARIES)
|
||||
file (WRITE
|
||||
${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testFortranCompiler1.f90
|
||||
"${CODE}"
|
||||
)
|
||||
TRY_RUN (${RUN_RESULT_VAR} ${COMPILE_RESULT_VAR}
|
||||
${CMAKE_BINARY_DIR}
|
||||
${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testFortranCompiler1.f90
|
||||
CMAKE_FLAGS "${CHECK_FUNCTION_EXISTS_ADD_LIBRARIES}"
|
||||
RUN_OUTPUT_VARIABLE OUTPUT
|
||||
)
|
||||
|
||||
set(${RETURN} ${OUTPUT})
|
||||
|
||||
#message ( "Test result1 ${RETURN} ")
|
||||
#message ( "Test result3 ${RESULT} ")
|
||||
#message ( "Test result2 ${CMAKE_MATCH_0} ")
|
||||
#message ( "Test result4 ${CMAKE_MATCH_1} ")
|
||||
#message ( "* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ")
|
||||
#message ( "Test result ${COMPILE_RESULT_VAR} ")
|
||||
#message ( "* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ")
|
||||
#message ( "Test result ${RUN_RESULT_VAR} ")
|
||||
#message ( "* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ")
|
||||
|
||||
if (${RUN_RESULT_VAR})
|
||||
set (${RUN_RESULT_VAR} 1 CACHE INTERNAL "Have Fortran function ${FUNCTION}")
|
||||
message (STATUS "Testing Fortran ${FUNCTION} - OK")
|
||||
file (APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
|
||||
"Determining if the Fortran ${FUNCTION} exists passed with the following output:\n"
|
||||
"${OUTPUT}\n\n"
|
||||
)
|
||||
else (${RUN_RESULT_VAR})
|
||||
message (STATUS "Testing Fortran ${FUNCTION} - Fail")
|
||||
set (${RUN_RESULT_VAR} "" CACHE INTERNAL "Have Fortran function ${FUNCTION}")
|
||||
file (APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
|
||||
"Determining if the Fortran ${FUNCTION} exists failed with the following output:\n"
|
||||
"${OUTPUT}\n\n")
|
||||
endif (${RUN_RESULT_VAR})
|
||||
# endif (NOT DEFINED ${RUN_RESULT_VAR})
|
||||
ENDMACRO (FORTRAN_RUN)
|
||||
|
||||
#-----------------------------------------------------------------------------
|
||||
# Check to see C_LONG_DOUBLE is available
|
||||
CHECK_FORTRAN_FEATURE(c_long_double
|
||||
"
|
||||
PROGRAM main
|
||||
USE ISO_C_BINDING
|
||||
REAL(KIND=C_LONG_DOUBLE) :: d
|
||||
END PROGRAM
|
||||
"
|
||||
FORTRAN_HAVE_C_LONG_DOUBLE
|
||||
)
|
||||
set(H5_FORTRAN_HAVE_C_LONG_DOUBLE ${FORTRAN_HAVE_C_LONG_DOUBLE})
|
||||
|
||||
# Check to see C_LONG_DOUBLE is different from C_DOUBLE
|
||||
|
||||
CHECK_FORTRAN_FEATURE(c_long_double
|
||||
"
|
||||
MODULE type_mod
|
||||
USE ISO_C_BINDING
|
||||
INTERFACE h5t
|
||||
MODULE PROCEDURE h5t_c_double
|
||||
MODULE PROCEDURE h5t_c_long_double
|
||||
END INTERFACE
|
||||
CONTAINS
|
||||
SUBROUTINE h5t_c_double(r)
|
||||
REAL(KIND=C_DOUBLE) :: r
|
||||
END SUBROUTINE h5t_c_double
|
||||
SUBROUTINE h5t_c_long_double(d)
|
||||
REAL(KIND=C_LONG_DOUBLE) :: d
|
||||
END SUBROUTINE h5t_c_long_double
|
||||
END MODULE type_mod
|
||||
PROGRAM main
|
||||
USE ISO_C_BINDING
|
||||
USE type_mod
|
||||
REAL(KIND=C_DOUBLE) :: r
|
||||
REAL(KIND=C_LONG_DOUBLE) :: d
|
||||
CALL h5t(r)
|
||||
CALL h5t(d)
|
||||
END PROGRAM main
|
||||
"
|
||||
FORTRAN_C_LONG_DOUBLE_IS_UNIQUE
|
||||
)
|
||||
|
||||
## Set the sizeof function for use later in the fortran tests
|
||||
if(FORTRAN_HAVE_STORAGE_SIZE)
|
||||
set(FC_SIZEOF_A "STORAGE_SIZE(a, c_size_t)/STORAGE_SIZE(c_char_'a',c_size_t)")
|
||||
set(FC_SIZEOF_B "STORAGE_SIZE(b, c_size_t)/STORAGE_SIZE(c_char_'a',c_size_t)")
|
||||
set(FC_SIZEOF_C "STORAGE_SIZE(c, c_size_t)/STORAGE_SIZE(c_char_'a',c_size_t)")
|
||||
elseif(FORTRAN_HAVE_C_SIZEOF)
|
||||
set(FC_SIZEOF_A "SIZEOF(a)")
|
||||
set(FC_SIZEOF_B "SIZEOF(b)")
|
||||
set(FC_SIZEOF_C "SIZEOF(c)")
|
||||
else(FORTRAN_HAVE_STORAGE_SIZE)
|
||||
message (FATAL_ERROR "Fortran compiler requires either intrinsic functions SIZEOF or STORAGE_SIZE")
|
||||
endif(FORTRAN_HAVE_STORAGE_SIZE)
|
||||
|
||||
#-----------------------------------------------------------------------------
|
||||
# Determine the available KINDs for REALs and INTEGERs
|
||||
#-----------------------------------------------------------------------------
|
||||
|
||||
FORTRAN_RUN("REAL and INTEGER KINDs"
|
||||
"
|
||||
PROGRAM main
|
||||
IMPLICIT NONE
|
||||
INTEGER :: ik, k, lastkind, max_decimal_prec
|
||||
INTEGER :: num_rkinds, num_ikinds
|
||||
num_ikinds = 0
|
||||
lastkind=SELECTED_INT_KIND(1)
|
||||
! Find integer KINDs
|
||||
DO ik=2,36
|
||||
k = SELECTED_INT_KIND(ik)
|
||||
IF (k .NE. lastkind) THEN
|
||||
num_ikinds = num_ikinds + 1
|
||||
WRITE(*,'(I0)',ADVANCE='NO') lastkind
|
||||
lastkind = k
|
||||
IF(k.GT.0) WRITE(*,'(A)',ADVANCE='NO') ','
|
||||
ENDIF
|
||||
IF (k .LE. 0) EXIT
|
||||
ENDDO
|
||||
IF (lastkind.NE.-1) THEN
|
||||
num_ikinds = num_ikinds + 1
|
||||
WRITE(*,'(I0)') lastkind
|
||||
ELSE
|
||||
WRITE(*,'()')
|
||||
ENDIF
|
||||
! Find real KINDs
|
||||
num_rkinds = 0
|
||||
lastkind=SELECTED_REAL_KIND(1)
|
||||
max_decimal_prec = 1
|
||||
DO ik=2,36
|
||||
k = SELECTED_REAL_KIND(ik)
|
||||
IF (k .NE. lastkind) THEN
|
||||
num_rkinds = num_rkinds + 1
|
||||
WRITE(*,'(I0)',ADVANCE='NO') lastkind
|
||||
lastkind = k
|
||||
IF(k.GT.0) WRITE(*,'(A)',ADVANCE='NO') ','
|
||||
max_decimal_prec = ik
|
||||
ENDIF
|
||||
IF (k .LE. 0) EXIT
|
||||
ENDDO
|
||||
IF (lastkind.NE.-1)THEN
|
||||
num_rkinds = num_rkinds + 1
|
||||
WRITE(*,'(I0)') lastkind
|
||||
ELSE
|
||||
WRITE(*,'()')
|
||||
ENDIF
|
||||
WRITE(*,'(I0)') max_decimal_prec
|
||||
WRITE(*,'(I0)') num_ikinds
|
||||
WRITE(*,'(I0)') num_rkinds
|
||||
END
|
||||
"
|
||||
XX
|
||||
YY
|
||||
PROG_OUTPUT
|
||||
)
|
||||
# dnl The output from the above program will be:
|
||||
# dnl -- LINE 1 -- valid integer kinds (comma seperated list)
|
||||
# dnl -- LINE 2 -- valid real kinds (comma seperated list)
|
||||
# dnl -- LINE 3 -- max decimal precision for reals
|
||||
# dnl -- LINE 4 -- number of valid integer kinds
|
||||
# dnl -- LINE 5 -- number of valid real kinds
|
||||
|
||||
# Convert the string to a list of strings by replacing the carriage return with a semicolon
|
||||
string(REGEX REPLACE "\n" ";" PROG_OUTPUT "${PROG_OUTPUT}")
|
||||
|
||||
list(GET PROG_OUTPUT 0 pac_validIntKinds)
|
||||
list(GET PROG_OUTPUT 1 pac_validRealKinds)
|
||||
list(GET PROG_OUTPUT 2 H5_PAC_FC_MAX_REAL_PRECISION)
|
||||
|
||||
set(PAC_FC_ALL_INTEGER_KINDS "\{${pac_validIntKinds}\}")
|
||||
set(PAC_FC_ALL_REAL_KINDS "\{${pac_validRealKinds}\}")
|
||||
|
||||
list(GET PROG_OUTPUT 3 NUM_IKIND)
|
||||
list(GET PROG_OUTPUT 4 NUM_RKIND)
|
||||
|
||||
set(H5CONFIG_F_NUM_IKIND "INTEGER, PARAMETER :: num_ikinds = ${NUM_IKIND}")
|
||||
set(H5CONFIG_F_IKIND "INTEGER, DIMENSION(1:num_ikinds) :: ikind = (/${pac_validIntKinds}/)")
|
||||
|
||||
message ( " ........REAL KINDS FOUND ${PAC_FC_ALL_REAL_KINDS}")
|
||||
message ( " ........INTEGER KINDS FOUND ${PAC_FC_ALL_REAL_KINDS}")
|
||||
message ( " ........MAX DECIMAL PRECISION ${H5_PAC_FC_MAX_REAL_PRECISION}")
|
||||
|
||||
#-----------------------------------------------------------------------------
|
||||
# Determine the available KINDs for REALs and INTEGERs
|
||||
#-----------------------------------------------------------------------------
|
||||
# **********
|
||||
# INTEGERS
|
||||
# **********
|
||||
string(REGEX REPLACE "," ";" VAR_KIND "${pac_validIntKinds}")
|
||||
|
||||
foreach( KIND ${VAR_KIND} )
|
||||
set(PROG_SRC
|
||||
"
|
||||
PROGRAM main
|
||||
USE ISO_C_BINDING
|
||||
IMPLICIT NONE
|
||||
INTEGER (KIND=${KIND}) a
|
||||
WRITE(*,'(I0)') ${FC_SIZEOF_A}
|
||||
END
|
||||
"
|
||||
)
|
||||
FORTRAN_RUN("INTEGER KIND SIZEOF" ${PROG_SRC}
|
||||
XX
|
||||
YY
|
||||
PROG_OUTPUT1
|
||||
)
|
||||
string(REGEX REPLACE "\n" "" PROG_OUTPUT1 "${PROG_OUTPUT1}")
|
||||
set(pack_int_sizeof "${pack_int_sizeof} ${PROG_OUTPUT1},")
|
||||
endforeach(KIND)
|
||||
string(STRIP ${pack_int_sizeof} pack_int_sizeof)
|
||||
|
||||
#Remove trailing comma
|
||||
string(REGEX REPLACE ",$" "" pack_int_sizeof "${pack_int_sizeof}")
|
||||
#Remove spaces
|
||||
string(REGEX REPLACE " " "" pack_int_sizeof "${pack_int_sizeof}")
|
||||
|
||||
set(PAC_FC_ALL_INTEGER_KINDS_SIZEOF "\{${pack_int_sizeof}\}")
|
||||
|
||||
# **********
|
||||
# REALS
|
||||
# **********
|
||||
string(REGEX REPLACE "," ";" VAR_KIND "${pac_validRealKinds}")
|
||||
|
||||
#find the maximum kind of the real
|
||||
list(LENGTH VAR_KIND LEN_VAR_KIND)
|
||||
MATH (EXPR _LEN "${LEN_VAR_KIND} - 1")
|
||||
list(GET VAR_KIND ${_LEN} max_real_fortran_kind)
|
||||
|
||||
foreach( KIND ${VAR_KIND} )
|
||||
set(PROG_SRC
|
||||
"
|
||||
PROGRAM main
|
||||
USE ISO_C_BINDING
|
||||
IMPLICIT NONE
|
||||
REAL (KIND=${KIND}) a
|
||||
WRITE(*,'(I0)') ${FC_SIZEOF_A}
|
||||
END
|
||||
"
|
||||
)
|
||||
FORTRAN_RUN("REAL KIND SIZEOF" ${PROG_SRC}
|
||||
XX
|
||||
YY
|
||||
PROG_OUTPUT1
|
||||
)
|
||||
string(REGEX REPLACE "\n" "" PROG_OUTPUT1 "${PROG_OUTPUT1}")
|
||||
set(pack_real_sizeof "${pack_real_sizeof} ${PROG_OUTPUT1},")
|
||||
endforeach(KIND)
|
||||
string(STRIP ${pack_real_sizeof} pack_real_sizeof)
|
||||
|
||||
#Remove trailing comma
|
||||
string(REGEX REPLACE ",$" "" pack_real_sizeof "${pack_real_sizeof}")
|
||||
#Remove spaces
|
||||
string(REGEX REPLACE " " "" pack_real_sizeof "${pack_real_sizeof}")
|
||||
|
||||
set(H5CONFIG_F_RKIND_SIZEOF "INTEGER, DIMENSION(1:num_rkinds) :: rkind_sizeof = (/${pack_real_sizeof}/)")
|
||||
|
||||
#find the maximum kind of the real
|
||||
list(LENGTH VAR_KIND LEN_VAR_KIND)
|
||||
MATH (EXPR _LEN "${LEN_VAR_KIND} - 1")
|
||||
list(GET VAR_KIND ${_LEN} max_real_fortran_sizeof)
|
||||
|
||||
set(PAC_FC_ALL_REAL_KINDS_SIZEOF "\{${pack_real_sizeof}\}")
|
||||
#-----------------------------------------------------------------------------
|
||||
# Find sizeof of native kinds
|
||||
#-----------------------------------------------------------------------------
|
||||
FORTRAN_RUN("SIZEOF NATIVE KINDs"
|
||||
"
|
||||
PROGRAM main
|
||||
USE ISO_C_BINDING
|
||||
IMPLICIT NONE
|
||||
INTEGER a
|
||||
REAL b
|
||||
DOUBLE PRECISION c
|
||||
WRITE(*,*) ${FC_SIZEOF_A}
|
||||
WRITE(*,*) kind(a)
|
||||
WRITE(*,*) ${FC_SIZEOF_B}
|
||||
WRITE(*,*) kind(b)
|
||||
WRITE(*,*) ${FC_SIZEOF_C}
|
||||
WRITE(*,*) kind(c)
|
||||
END
|
||||
"
|
||||
XX
|
||||
YY
|
||||
PROG_OUTPUT
|
||||
)
|
||||
# dnl The output from the above program will be:
|
||||
# dnl -- LINE 1 -- sizeof INTEGER
|
||||
# dnl -- LINE 2 -- kind of INTEGER
|
||||
# dnl -- LINE 3 -- sizeof REAL
|
||||
# dnl -- LINE 4 -- kind of REAL
|
||||
# dnl -- LINE 5 -- sizeof DOUBLE PRECISION
|
||||
# dnl -- LINE 6 -- kind of DOUBLE PRECISION
|
||||
|
||||
# Convert the string to a list of strings by replacing the carriage return with a semicolon
|
||||
string(REGEX REPLACE "\n" ";" PROG_OUTPUT "${PROG_OUTPUT}")
|
||||
|
||||
list(GET PROG_OUTPUT 0 PAC_FORTRAN_NATIVE_INTEGER_SIZEOF)
|
||||
list(GET PROG_OUTPUT 1 PAC_FORTRAN_NATIVE_INTEGER_KIND)
|
||||
list(GET PROG_OUTPUT 2 PAC_FORTRAN_NATIVE_REAL_SIZEOF)
|
||||
list(GET PROG_OUTPUT 3 PAC_FORTRAN_NATIVE_REAL_KIND)
|
||||
list(GET PROG_OUTPUT 4 PAC_FORTRAN_NATIVE_DOUBLE_SIZEOF)
|
||||
list(GET PROG_OUTPUT 5 PAC_FORTRAN_NATIVE_DOUBLE_KIND)
|
||||
|
||||
set(FORTRAN_SIZEOF_LONG_DOUBLE ${HDF_PREFIX}_SIZEOF_LONG_DOUBLE)
|
||||
|
||||
# remove the invalid kind from the list
|
||||
if(NOT(${SIZEOF___FLOAT128} EQUAL 0))
|
||||
if(NOT(${SIZEOF___FLOAT128} EQUAL ${max_real_fortran_sizeof}) AND NOT(${FORTRAN_SIZEOF_LONG_DOUBLE} EQUAL ${max_real_fortran_sizeof}))
|
||||
message(WARNING "
|
||||
Fortran REAL(KIND=${max_real_fortran_kind}) is $max_real_fortran_sizeof Bytes, but no corresponding C float type exists of that size
|
||||
!!! Fortran interfaces will not be generated for REAL(KIND=${max_real_fortran_kind}) !!!")
|
||||
string(REGEX REPLACE ",[0-9]+}" "}" PAC_FC_ALL_REAL_KINDS ${PAC_FC_ALL_REAL_KINDS})
|
||||
string(REGEX REPLACE ",[0-9]+}" "}" PAC_FC_ALL_REAL_KINDS_SIZEOF ${PAC_FC_ALL_REAL_KINDS_SIZEOF})
|
||||
MATH (EXPR NUM_RKIND "${NUM_RKIND} - 1")
|
||||
endif(NOT(${SIZEOF___FLOAT128} EQUAL ${max_real_fortran_sizeof}) AND NOT(${FORTRAN_SIZEOF_LONG_DOUBLE} EQUAL ${max_real_fortran_sizeof}))
|
||||
endif(NOT(${SIZEOF___FLOAT128} EQUAL 0))
|
||||
|
||||
set(H5CONFIG_F_NUM_RKIND "INTEGER, PARAMETER :: num_rkinds = ${NUM_RKIND}")
|
||||
|
||||
string(REGEX REPLACE "{" "" OUT_VAR ${PAC_FC_ALL_REAL_KINDS})
|
||||
string(REGEX REPLACE "}" "" OUT_VAR ${OUT_VAR})
|
||||
set(H5CONFIG_F_RKIND "INTEGER, DIMENSION(1:num_rkinds) :: rkind = (/${OUT_VAR}/)")
|
||||
|
||||
string(REGEX REPLACE "{" "" OUT_VAR ${PAC_FC_ALL_REAL_KINDS_SIZEOF})
|
||||
string(REGEX REPLACE "}" "" OUT_VAR ${OUT_VAR})
|
||||
set(H5CONFIG_F_RKIND_SIZEOF "INTEGER, DIMENSION(1:num_rkinds) :: rkind_sizeof = (/${OUT_VAR}/)")
|
||||
|
||||
ENABLE_LANGUAGE (C)
|
||||
|
||||
#-----------------------------------------------------------------------------
|
||||
# The provided CMake C macros don't provide a general compile/run function
|
||||
# so this one is used.
|
||||
#-----------------------------------------------------------------------------
|
||||
MACRO (C_RUN FUNCTION CODE RUN_RESULT_VAR COMPILE_RESULT_VAR RETURN)
|
||||
# MSB CHECK WHY THIS CHECK?
|
||||
# if (NOT DEFINED ${RUN_RESULT_VAR})
|
||||
message (STATUS "Detecting C ${FUNCTION}")
|
||||
if (CMAKE_REQUIRED_LIBRARIES)
|
||||
set (CHECK_FUNCTION_EXISTS_ADD_LIBRARIES
|
||||
"-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
|
||||
else (CMAKE_REQUIRED_LIBRARIES)
|
||||
set (CHECK_FUNCTION_EXISTS_ADD_LIBRARIES)
|
||||
endif (CMAKE_REQUIRED_LIBRARIES)
|
||||
file (WRITE
|
||||
${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testCCompiler1.c
|
||||
${CODE}
|
||||
)
|
||||
TRY_RUN (${RUN_RESULT_VAR} ${COMPILE_RESULT_VAR}
|
||||
${CMAKE_BINARY_DIR}
|
||||
${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testCCompiler1.c
|
||||
CMAKE_FLAGS "${CHECK_FUNCTION_EXISTS_ADD_LIBRARIES}"
|
||||
RUN_OUTPUT_VARIABLE OUTPUT
|
||||
)
|
||||
|
||||
set(${RETURN} ${OUTPUT})
|
||||
|
||||
#message ( "Test result1 ${RETURN} ")
|
||||
#message ( "Test result3 ${RESULT} ")
|
||||
#message ( "Test result2 ${CMAKE_MATCH_0} ")
|
||||
#message ( "Test result4 ${CMAKE_MATCH_1} ")
|
||||
#message ( "* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ")
|
||||
#message ( "Test result ${COMPILE_RESULT_VAR} ")
|
||||
#message ( "* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ")
|
||||
#message ( "Test result ${RUN_RESULT_VAR} ")
|
||||
#message ( "* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ")
|
||||
|
||||
if (${RUN_RESULT_VAR})
|
||||
set (${RUN_RESULT_VAR} 1 CACHE INTERNAL "Have C function ${FUNCTION}")
|
||||
message (STATUS "Testing C ${FUNCTION} - OK")
|
||||
file (APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
|
||||
"Determining if the C ${FUNCTION} exists passed with the following output:\n"
|
||||
"${OUTPUT}\n\n"
|
||||
)
|
||||
else (${RUN_RESULT_VAR})
|
||||
message (STATUS "Testing C ${FUNCTION} - Fail")
|
||||
set (${RUN_RESULT_VAR} "" CACHE INTERNAL "Have C function ${FUNCTION}")
|
||||
file (APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
|
||||
"Determining if the C ${FUNCTION} exists failed with the following output:\n"
|
||||
"${OUTPUT}\n\n")
|
||||
endif (${RUN_RESULT_VAR})
|
||||
# endif (NOT DEFINED ${RUN_RESULT_VAR})
|
||||
ENDMACRO (C_RUN)
|
||||
|
||||
set(PROG_SRC
|
||||
"
|
||||
#include <float.h>
|
||||
#include <stdio.h>
|
||||
#define CHECK_FLOAT128 ${SIZEOF___FLOAT128}
|
||||
#if CHECK_FLOAT128!=0
|
||||
# if ${HAVE_QUADMATH}!=0
|
||||
#include <quadmath.h>
|
||||
# endif
|
||||
# ifdef FLT128_DIG
|
||||
#define C_FLT128_DIG FLT128_DIG
|
||||
# else
|
||||
#define C_FLT128_DIG 0
|
||||
# endif
|
||||
#else
|
||||
#define C_FLT128_DIG 0
|
||||
#endif
|
||||
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
|
||||
#define C_LDBL_DIG DECIMAL_DIG
|
||||
#else
|
||||
#define C_LDBL_DIG LDBL_DIG
|
||||
#endif
|
||||
void main() {
|
||||
printf(\"%d\\\\n%d\\\\n\", C_LDBL_DIG, C_FLT128_DIG)\\\;
|
||||
}
|
||||
"
|
||||
)
|
||||
|
||||
C_RUN("maximum decimal precision for C" ${PROG_SRC}
|
||||
XX
|
||||
YY
|
||||
PROG_OUTPUT
|
||||
)
|
||||
|
||||
# dnl The output from the above program will be:
|
||||
# dnl -- LINE 1 -- long double decimal precision
|
||||
# dnl -- LINE 2 -- __float128 decimal precision
|
||||
|
||||
# Convert the string to a list of strings by replacing the carriage return with a semicolon
|
||||
string(REGEX REPLACE "\n" ";" PROG_OUTPUT "${PROG_OUTPUT}")
|
||||
|
||||
list(GET PROG_OUTPUT 0 LDBL_DIG)
|
||||
list(GET PROG_OUTPUT 1 FLT128_DIG)
|
||||
|
||||
if(SIZEOF___FLOAT128 EQUAL 0)
|
||||
set(H5_PAC_C_MAX_REAL_PRECISION ${LDBL_DIG})
|
||||
else (SIZEOF___FLOAT128 EQUAL 0)
|
||||
set(H5_PAC_C_MAX_REAL_PRECISION ${FLT128_DIG})
|
||||
endif(SIZEOF___FLOAT128 EQUAL 0)
|
||||
|
||||
|
||||
# Setting definition if there is a 16 byte fortran integer
|
||||
string(FIND ${PAC_FC_ALL_INTEGER_KINDS_SIZEOF} "16" pos)
|
||||
if(${pos} EQUAL -1)
|
||||
set(HAVE_Fortran_INTEGER_SIZEOF_16 0)
|
||||
else (${pos} EQUAL -1)
|
||||
set(HAVE_Fortran_INTEGER_SIZEOF_16 1)
|
||||
endif (${pos} EQUAL -1)
|
||||
Loading…
Reference in New Issue
Block a user