Check if intrinsic module constant is defined - fortran

Question

The Fortran standard evolves and as new intrinsic variables are introduced, compilers pick those up after a while. One example is the variable C_PTRDIFF_T.
To make my code compilable with older compilers as well, I'd like to define intrinsic variables if they are not already defined by the compiler itself, e.g,
program test
USE ISO_C_BINDING
Integer, Parameter :: C_PTRDIFF_T = 12
end program
How can I make this portable across compilers?

Answer 1

Try and compile and run something akin to:
USE, INTRINSIC :: ISO_C_BINDING, ONLY: C_PTRDIFF_T
IF (C_PTRDIFF_T >= 0) THEN
PRINT "('Ok')"
ELSE
PRINT "('Not ok')"
END IF
END
If compilation suceeds, the compiler is aware of the standard that supports C_PTRDIFF_T.
If running the program then prints Ok (so the value of C_PTRDIFF_T constant is non-negative), the processor also supports an integer that is interoperable with the relevant C type.
Based on this test you can then configure your program proper as appropriate, perhaps by selecting slightly different source code for a module that either provides a stand-alone definition of or forwards C_PTRDIFF_T from ISO_C_BINDING.
The ability for later standards to add new entities to the intrinsic modules is why a programming style that always uses an ONLY clause on USE statements for intrinsic modules is sometimes recommended.
(Note C_PTRDIFF_T is a constant in an intrinsic module, it is not a variable nor intrinsic.)

Answer 2

You can achieve this within a procedure because USE association trumps host association:
module goodstuf
implicit none
interface f
module procedure f4, f8
end interface f
contains
function f4(x)
integer(4) f4
integer(4), intent(in) :: x
f4 = x**2+1
end function f4
function f8(x)
integer(8) f8
integer(8), intent(in) :: x
f8 = x**3-1
end function f8
end module goodstuf
module user5713492_C_BINDING
implicit none
! integer, parameter :: C_PTRDIFF_T = 8
end module user5713492_C_BINDING
module anymod
use goodstuf
implicit none
integer, parameter :: C_PTRDIFF_T = 4
contains
subroutine sub
use user5713492_C_BINDING
integer(C_PTRDIFF_T) x
x = 7
write(*,*) f(x)
end subroutine sub
end module anymod
program main
use anymod
implicit none
call sub
end program main
This prints out 50 when the definition of C_PTRDIFF_T is commented out in module user5713492_C_BINDING and 342 when it is in effect. But what I was hoping to do was to define a named constant that had the value 1 when C_PTRDIFF_T was define and 0 when not. I could achieve this for the named constant test via the STORAGE_SIZE, BIT_SIZE, and DIM intrinsics using implicit typing assuming the KIND of a default integer was not INT8. But then to squash C_PTRDIFF_T when it's not defined seems to require a compiler bug of some sort. I tried this with gfortran and turned up a couple of bugs, and finally one that allowed this to work, squashing the FSOURCE= argument to the MERGE intrinsic. It didn't work with ifort, unfortunately.
module goodstuf
implicit none
interface f
module procedure f4, f8
end interface f
contains
function f4(x)
integer(4) f4
integer(4), intent(in) :: x
f4 = x**2+1
end function f4
function f8(x)
integer(8) f8
integer(8), intent(in) :: x
f8 = x**3-1
end function f8
end module goodstuf
module user5713492_C_BINDING
implicit none
! integer, parameter :: C_PTRDIFF_T = 8
end module user5713492_C_BINDING
module filter
use user5713492_C_BINDING
use ISO_FORTRAN_ENV, only: INT8
implicit integer(INT8) (C)
integer, parameter :: PTRDIFF_size = storage_size(C_PTRDIFF_T)
integer, parameter :: test = dim(1,(PTRDIFF_size-bit_size(1))**2)
integer, parameter :: MY_PTRDIFF_T = 4
! First test: try to squash PAD= argument to RESHAPE
! integer, parameter :: array1(test) = reshape([integer(INT8)::],[test],pad=[C_PTRDIFF_T])
! integer, parameter :: array2(1) = reshape(array1,[1],pad=[MY_PTRDIFF_T])
! Second test: try to squash assignment to zero-length array
! integer, parameter :: array1(test) = C_PTRDIFF_T
! integer, parameter :: array2(1) = reshape(array1,[1],pad=[MY_PTRDIFF_T])
! Third test: try to squash zero-length structure constructor
! Fails with gfortran with C_PTRDIFF_T defined. Bug?
! type T
! integer array(test)
! end type T
! type(T), parameter :: T1 = T(C_PTRDIFF_T)
! integer, parameter :: array2(1) = reshape(T1%array,[1],pad=[MY_PTRDIFF_T])
! Fourth test: try to squash BOUNDARY= argument to EOSHIFT
! gfortan gives misleading error message with C_PTRDIFF_T undefined.
! integer, parameter :: array2(1) = eoshift([integer(KIND(C_PTRDIFF_T))::MY_PTRDIFF_T],1,boundary=C_PTRDIFF_T)
! Fifth test: try to squash FSOURCE= argument to MERGE
!!! WORKS WITH gfortran!!!
integer, parameter :: array2(1) = merge([integer(KIND(C_PTRDIFF_T))::MY_PTRDIFF_T],C_PTRDIFF_T,test==0)
integer, parameter :: OK_PTRDIFF_T = array2(1)
end module filter
program main
use goodstuf
use filter
implicit none
integer(OK_PTRDIFF_T) x
x = 7
write(*,*) f(x)
end program main