1488 строки
46 KiB
Plaintext
1488 строки
46 KiB
Plaintext
dnl PAC_F77_SEARCH_LIST - expands to a whitespace separated list of fortran 77
|
|
dnl compilers for use with AC_PROG_F77 that is more suitable for HPC software
|
|
dnl packages
|
|
AC_DEFUN([PAC_F77_SEARCH_LIST],[ifort pgf77 af77 xlf frt cf77 fort77 fl32 fort ifc efc ftn gfortran f77 g77])
|
|
dnl PAC_PROG_F77 - reprioritize the F77 compiler search order
|
|
dnl NOTE: this macro suffers from a basically intractable "expanded before it
|
|
dnl was required" problem when libtool is also used
|
|
AC_DEFUN([PAC_PROG_F77],[
|
|
PAC_PUSH_FLAG([FFLAGS])
|
|
AC_PROG_F77([PAC_F77_SEARCH_LIST])
|
|
PAC_POP_FLAG([FFLAGS])
|
|
])
|
|
dnl
|
|
dnl/*D
|
|
dnl PAC_PROG_F77_NAME_MANGLE - Determine how the Fortran compiler mangles
|
|
dnl names
|
|
dnl
|
|
dnl Synopsis:
|
|
dnl PAC_PROG_F77_NAME_MANGLE([action])
|
|
dnl
|
|
dnl Output Effect:
|
|
dnl If no action is specified, one of the following names is defined:
|
|
dnl.vb
|
|
dnl If fortran names are mapped:
|
|
dnl lower -> lower F77_NAME_LOWER
|
|
dnl lower -> lower_ F77_NAME_LOWER_USCORE
|
|
dnl lower -> UPPER F77_NAME_UPPER
|
|
dnl lower_lower -> lower__ F77_NAME_LOWER_2USCORE
|
|
dnl mixed -> mixed F77_NAME_MIXED
|
|
dnl mixed -> mixed_ F77_NAME_MIXED_USCORE
|
|
dnl mixed -> UPPER@STACK_SIZE F77_NAME_UPPER_STDCALL
|
|
dnl.ve
|
|
dnl If an action is specified, it is executed instead.
|
|
dnl
|
|
dnl Notes:
|
|
dnl We assume that if lower -> lower (any underscore), upper -> upper with the
|
|
dnl same underscore behavior. Previous versions did this by
|
|
dnl compiling a Fortran program and running strings -a over it. Depending on
|
|
dnl strings is a bad idea, so instead we try compiling and linking with a
|
|
dnl C program, since that is why we are doing this anyway. A similar approach
|
|
dnl is used by FFTW, though without some of the cases we check (specifically,
|
|
dnl mixed name mangling). STD_CALL not only specifies a particular name
|
|
dnl mangling convention (adding the size of the calling stack into the function
|
|
dnl name, but also the stack management convention (callee cleans the stack,
|
|
dnl and arguments are pushed onto the stack from right to left)
|
|
dnl
|
|
dnl One additional problem is that some Fortran implementations include
|
|
dnl references to the runtime (like pgf90_compiled for the pgf90 compiler
|
|
dnl used as the "Fortran 77" compiler). This is not yet solved.
|
|
dnl
|
|
dnl D*/
|
|
dnl
|
|
AC_DEFUN([PAC_PROG_F77_NAME_MANGLE],[
|
|
AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])
|
|
AC_CACHE_CHECK([for Fortran 77 name mangling],
|
|
pac_cv_prog_f77_name_mangle,[
|
|
# Initialize pac_found to indicate if name mangling scheme has been found
|
|
pac_found=no
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
subroutine MY_name( ii )
|
|
return
|
|
end
|
|
])
|
|
],[
|
|
PAC_RUNLOG([mv conftest.$OBJEXT f77conftest.$OBJEXT])
|
|
saved_LIBS="$LIBS"
|
|
dnl FLIBS is set by AC_F77_LIBRARY_LDFLAGS
|
|
LIBS="f77conftest.$OBJEXT $FLIBS $LIBS"
|
|
AC_LANG_PUSH([C])
|
|
for call in "" __stdcall ; do
|
|
for sym in my_name_ my_name__ my_name MY_NAME MY_name MY_name_ NONE ; do
|
|
AC_LINK_IFELSE([
|
|
AC_LANG_PROGRAM([extern void ${call} ${sym}(int);],[${sym}(0);])
|
|
],[
|
|
pac_found=yes
|
|
break
|
|
])
|
|
done
|
|
test "$pac_found" = "yes" && break
|
|
done
|
|
AC_LANG_POP([C])
|
|
LIBS="$saved_LIBS"
|
|
rm -f f77conftest.$OBJEXT
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
dnl
|
|
# If we got to here and pac_cv_prog_f77_name_mangle is still NOT definable,
|
|
# it may be that the programs have to be linked with the Fortran compiler,
|
|
# not the C compiler. Try reversing the language used for the test
|
|
if test "$pac_found" != "yes" ; then
|
|
AC_LANG_PUSH([C])
|
|
for call in "" __stdcall ; do
|
|
for sym in my_name_ my_name__ my_name MY_NAME MY_name MY_name_ NONE ; do
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_SOURCE([void ${call} ${sym}(int a) {}])
|
|
],[
|
|
PAC_RUNLOG([mv conftest.$OBJEXT cconftest.$OBJEXT])
|
|
saved_LIBS="$LIBS"
|
|
LIBS="cconftest.$OBJEXT $LIBS"
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_LINK_IFELSE([
|
|
AC_LANG_PROGRAM([],[ call my_name(0)])
|
|
],[
|
|
pac_found=yes
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
LIBS="$saved_LIBS"
|
|
rm -f cconftest.$OBJEXT
|
|
test "$pac_found" = "yes" && break
|
|
])
|
|
done
|
|
test "$pac_found" = "yes" && break
|
|
done
|
|
AC_LANG_POP([C])
|
|
fi
|
|
if test "$pac_found" = "yes" ; then
|
|
case ${sym} in
|
|
my_name_)
|
|
pac_cv_prog_f77_name_mangle="lower uscore" ;;
|
|
my_name__)
|
|
pac_cv_prog_f77_name_mangle="lower 2uscore" ;;
|
|
my_name)
|
|
pac_cv_prog_f77_name_mangle="lower" ;;
|
|
MY_NAME)
|
|
pac_cv_prog_f77_name_mangle="upper" ;;
|
|
MY_name)
|
|
pac_cv_prog_f77_name_mangle="mixed" ;;
|
|
MY_name_)
|
|
pac_cv_prog_f77_name_mangle="mixed uscore" ;;
|
|
*)
|
|
pac_cv_prog_f77_name_mangle=""
|
|
pac_found=no;
|
|
;;
|
|
esac
|
|
if test "X$pac_cv_prog_f77_name_mangle" != "X" ; then
|
|
if test "$call" = "__stdcall" ; then
|
|
pac_cv_prog_f77_name_mangle="$pac_cv_prog_f77_name_mangle stdcall"
|
|
fi
|
|
fi
|
|
fi
|
|
])
|
|
dnl Endof ac_cache_check
|
|
case $pac_cv_prog_f77_name_mangle in
|
|
*stdcall)
|
|
F77_STDCALL="__stdcall" ;;
|
|
*)
|
|
F77_STDCALL="" ;;
|
|
esac
|
|
# Get the standard call definition
|
|
# FIXME: This should use F77_STDCALL, not STDCALL (non-conforming name)
|
|
F77_STDCALL="$call"
|
|
AC_DEFINE_UNQUOTED(STDCALL,[$F77_STDCALL],[Define calling convention])
|
|
|
|
# new_name="`echo $name | tr ' ' '_' | tr [a-z] [A-Z]`"
|
|
# We could have done the character conversion with 'tr'
|
|
# which may not be portable, e.g. solaris's /usr/ucb/bin/tr.
|
|
# So use a conservative approach.
|
|
|
|
# Replace blank with underscore
|
|
name_scheme="`echo $pac_cv_prog_f77_name_mangle | sed 's% %_%g'`"
|
|
# Turn lowercase into uppercase.
|
|
name_scheme="`echo $name_scheme | sed -e 'y%abcdefghijklmnopqrstuvwxyz%ABCDEFGHIJKLMNOPQRSTUVWXYZ%'`"
|
|
F77_NAME_MANGLE="F77_NAME_${name_scheme}"
|
|
AC_DEFINE_UNQUOTED([$F77_NAME_MANGLE])
|
|
AC_SUBST(F77_NAME_MANGLE)
|
|
if test "X$pac_cv_prog_f77_name_mangle" = "X" ; then
|
|
AC_MSG_WARN([Unknown Fortran naming scheme])
|
|
fi
|
|
dnl
|
|
dnl Define the macros that is needed by AC_DEFINE_UNQUOTED([$F77_NAME_MANGLE])
|
|
AH_TEMPLATE([F77_NAME_LOWER],
|
|
[Fortran names are lowercase with no trailing underscore])
|
|
AH_TEMPLATE([F77_NAME_LOWER_USCORE],
|
|
[Fortran names are lowercase with one trailing underscore])
|
|
AH_TEMPLATE([F77_NAME_LOWER_2USCORE],
|
|
[Fortran names are lowercase with two trailing underscores])
|
|
AH_TEMPLATE([F77_NAME_MIXED],
|
|
[Fortran names preserve the original case])
|
|
AH_TEMPLATE([F77_NAME_MIXED_USCORE],
|
|
[Fortran names preserve the original case with one trailing underscore])
|
|
AH_TEMPLATE([F77_NAME_UPPER],
|
|
[Fortran names are uppercase])
|
|
AH_TEMPLATE([F77_NAME_LOWER_STDCALL],
|
|
[Fortran names are lowercase with no trailing underscore in stdcall])
|
|
AH_TEMPLATE([F77_NAME_LOWER_USCORE_STDCALL],
|
|
[Fortran names are lowercase with one trailing underscore in stdcall])
|
|
AH_TEMPLATE([F77_NAME_LOWER_2USCORE_STDCALL],
|
|
[Fortran names are lowercase with two trailing underscores in stdcall])
|
|
AH_TEMPLATE([F77_NAME_MIXED_STDCALL],
|
|
[Fortran names preserve the original case in stdcall])
|
|
AH_TEMPLATE([F77_NAME_MIXED_USCORE_STDCALL],
|
|
[Fortran names preserve the original case with one trailing underscore in stdcall])
|
|
AH_TEMPLATE([F77_NAME_UPPER_STDCALL],
|
|
[Fortran names are uppercase in stdcall])
|
|
])
|
|
dnl
|
|
dnl/*D
|
|
dnl PAC_PROG_F77_CHECK_SIZEOF - Determine the size in bytes of a Fortran
|
|
dnl type
|
|
dnl
|
|
dnl Synopsis:
|
|
dnl PAC_PROG_F77_CHECK_SIZEOF(type,[cross-size])
|
|
dnl
|
|
dnl Output Effect:
|
|
dnl Sets SIZEOF_F77_uctype to the size if bytes of type.
|
|
dnl If type is unknown, the size is set to 0.
|
|
dnl If cross-compiling, the value cross-size is used (it may be a variable)
|
|
dnl For example 'PAC_PROG_F77_CHECK_SIZEOF(real)' defines
|
|
dnl 'SIZEOF_F77_REAL' to 4 on most systems. The variable
|
|
dnl 'pac_cv_sizeof_f77_<type>' (e.g., 'pac_cv_sizeof_f77_real') is also set to
|
|
dnl the size of the type.
|
|
dnl If the corresponding variable is already set, that value is used.
|
|
dnl If the name has an '*' in it (e.g., 'integer*4'), the defined name
|
|
dnl replaces that with an underscore (e.g., 'SIZEOF_F77_INTEGER_4').
|
|
dnl
|
|
dnl Notes:
|
|
dnl If the 'cross-size' argument is not given, 'autoconf' will issue an error
|
|
dnl message. You can use '0' to specify undetermined.
|
|
dnl
|
|
dnl D*/
|
|
AC_DEFUN([PAC_PROG_F77_CHECK_SIZEOF],[
|
|
AC_REQUIRE([AC_HEADER_STDC])
|
|
AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])
|
|
changequote(<<, >>)dnl
|
|
dnl The name to #define.
|
|
dnl dnl If the arg value contains a variable, we need to update that
|
|
define(<<PAC_TYPE_NAME>>, translit(sizeof_f77_$1, [a-z *], [A-Z__]))dnl
|
|
dnl The cache variable name.
|
|
define(<<PAC_CV_NAME>>, translit(pac_cv_f77_sizeof_$1, [ *], [__]))dnl
|
|
changequote([, ])dnl
|
|
AC_CACHE_CHECK([for size of Fortran type $1],PAC_CV_NAME,[
|
|
AC_REQUIRE([PAC_PROG_F77_NAME_MANGLE])
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
subroutine isize()
|
|
$1 i(2)
|
|
call cisize( i(1), i(2) )
|
|
end
|
|
])
|
|
],[
|
|
# pac_f77compile_ok=yes
|
|
PAC_RUNLOG([mv conftest.$OBJEXT pac_f77conftest.$OBJEXT])
|
|
# Save original LIBS, prepend previously generated object file to LIBS
|
|
saved_LIBS="$LIBS"
|
|
LIBS="pac_f77conftest.$OBJEXT $FLIBS $LIBS"
|
|
AC_LANG_PUSH([C])
|
|
AC_RUN_IFELSE([
|
|
AC_LANG_PROGRAM([
|
|
#if defined(HAVE_STDIO_H) || defined(STDC_HEADERS)
|
|
#include <stdio.h>
|
|
#endif
|
|
#ifdef F77_NAME_UPPER
|
|
#define cisize_ CISIZE
|
|
#define isize_ ISIZE
|
|
#elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED)
|
|
#define cisize_ cisize
|
|
#define isize_ isize
|
|
#endif
|
|
static int isize_val=0;
|
|
void cisize_(char *,char*);
|
|
void isize_(void);
|
|
void cisize_(char *i1p, char *i2p)
|
|
{
|
|
isize_val = (int)(i2p - i1p);
|
|
}
|
|
],[
|
|
FILE *f = fopen("conftestval", "w");
|
|
if (!f) return 1;
|
|
isize_();
|
|
fprintf(f,"%d\n", isize_val);
|
|
])
|
|
dnl Endof ac_lang_program
|
|
],[
|
|
eval PAC_CV_NAME=`cat conftestval`
|
|
],[
|
|
eval PAC_CV_NAME=0
|
|
],[
|
|
# Use -9999 as value to emit a warning message after the cache_check.
|
|
ifelse([$2],[],[eval PAC_CV_NAME=-9999],[eval PAC_CV_NAME=$2])
|
|
])
|
|
dnl Endof ac_run_ifelse
|
|
AC_LANG_POP([C])
|
|
LIBS="$saved_LIBS"
|
|
# remove previously generated object file.
|
|
rm -f pac_f77conftest.$OBJEXT
|
|
],[
|
|
# pac_f77compile_ok=no
|
|
ifelse([$2],,eval PAC_CV_NAME=0,eval PAC_CV_NAME=$2)
|
|
]) Endof ac_compile_ifelse
|
|
AC_LANG_POP([Fortran 77])
|
|
])
|
|
dnl Endof ac_cache_check
|
|
if test "$PAC_CV_NAME" = "-9999" ; then
|
|
AC_MSG_WARN([No value provided for size of $1 when cross-compiling])
|
|
fi
|
|
AC_DEFINE_UNQUOTED(PAC_TYPE_NAME,$PAC_CV_NAME,[Define size of PAC_TYPE_NAME])
|
|
undefine([PAC_TYPE_NAME])
|
|
undefine([PAC_CV_NAME])
|
|
])
|
|
dnl
|
|
dnl This version uses a Fortran program to link programs.
|
|
dnl This is necessary because some compilers provide shared libraries
|
|
dnl that are not within the default linker paths (e.g., our installation
|
|
dnl of the Portland Group compilers)
|
|
dnl
|
|
AC_DEFUN([PAC_PROG_F77_CHECK_SIZEOF_EXT],[
|
|
changequote(<<,>>)dnl
|
|
dnl The name to #define.
|
|
dnl If the arg value contains a variable, we need to update that
|
|
define(<<PAC_TYPE_NAME>>, translit(sizeof_f77_$1, [a-z *], [A-Z__]))dnl
|
|
dnl The cache variable name.
|
|
define(<<PAC_CV_NAME>>, translit(pac_cv_f77_sizeof_$1, [ *], [__]))dnl
|
|
changequote([,])dnl
|
|
AC_CACHE_CHECK([for size of Fortran type $1],PAC_CV_NAME,[
|
|
AC_REQUIRE([AC_HEADER_STDC])
|
|
AC_REQUIRE([PAC_PROG_F77_NAME_MANGLE])
|
|
dnl if test "$cross_compiling" = yes ; then
|
|
dnl ifelse([$2],[],
|
|
dnl [AC_MSG_WARN([No value provided for size of $1 when cross-compiling])],
|
|
dnl [eval PAC_CV_NAME=$2])
|
|
dnl fi
|
|
AC_LANG_PUSH([C])
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
#if defined(HAVE_STDIO_H) || defined(STDC_HEADERS)
|
|
#include <stdio.h>
|
|
#endif
|
|
#ifdef F77_NAME_UPPER
|
|
#define cisize_ CISIZE
|
|
#define isize_ ISIZE
|
|
#elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED)
|
|
#define cisize_ cisize
|
|
#define isize_ isize
|
|
#endif
|
|
int cisize_(char *,char*);
|
|
int cisize_(char *i1p, char *i2p) {
|
|
int isize_val=0;
|
|
FILE *f = fopen("conftestval", "w");
|
|
if (!f) return 1;
|
|
isize_val = (int)(i2p - i1p);
|
|
fprintf(f,"%d\n", isize_val);
|
|
fclose(f);
|
|
return 0;
|
|
}
|
|
])
|
|
dnl Endof ac_lang_source
|
|
],[
|
|
# pac_compile_ok=yes
|
|
PAC_RUNLOG([mv conftest.$OBJEXT pac_conftest.$OBJEXT])
|
|
# Save LIBS and prepend object file to LIBS
|
|
saved_LIBS="$LIBS"
|
|
LIBS="pac_conftest.$OBJEXT $LIBS"
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_RUN_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
program main
|
|
$1 a(2)
|
|
integer irc, cisize
|
|
irc = cisize(a(1),a(2))
|
|
end
|
|
])
|
|
],[
|
|
eval PAC_CV_NAME=`cat conftestval`
|
|
],[
|
|
eval PAC_CV_NAME=0
|
|
],[
|
|
# Use -9999 as value to emit a warning message after the cache_check.
|
|
ifelse([$2],[],[eval PAC_CV_NAME=-9999],[eval PAC_CV_NAME=$2])
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
LIBS="$saved_LIBS"
|
|
# remove previously generated object file.
|
|
rm -f pac_conftest.$OBJEXT
|
|
],[
|
|
AC_MSG_WARN([Unable to compile the C routine for finding the size of a $1])
|
|
])
|
|
AC_LANG_POP([C])
|
|
])
|
|
dnl Endof ac_cache_check
|
|
if test "$PAC_CV_NAME" = "-9999" ; then
|
|
AC_MSG_WARN([No value provided for size of $1 when cross-compiling])
|
|
fi
|
|
AC_DEFINE_UNQUOTED(PAC_TYPE_NAME,$PAC_CV_NAME,[Define size of PAC_TYPE_NAME])
|
|
undefine([PAC_TYPE_NAME])
|
|
undefine([PAC_CV_NAME])
|
|
])
|
|
dnl
|
|
dnl/*D
|
|
dnl PAC_PROG_F77_EXCLAIM_COMMENTS
|
|
dnl
|
|
dnl Synopsis:
|
|
dnl PAC_PROG_F77_EXCLAIM_COMMENTS([action-if-true],[action-if-false])
|
|
dnl
|
|
dnl Notes:
|
|
dnl Check whether '!' may be used to begin comments in Fortran.
|
|
dnl
|
|
dnl This macro requires a version of autoconf `after` 2.13; the 'acgeneral.m4'
|
|
dnl file contains an error in the handling of Fortran programs in
|
|
dnl 'AC_TRY_COMPILE' (fixed in our local version).
|
|
dnl
|
|
dnl D*/
|
|
AC_DEFUN([PAC_PROG_F77_EXCLAIM_COMMENTS],[
|
|
AC_CACHE_CHECK([whether Fortran 77 accepts ! for comments],
|
|
pac_cv_prog_f77_exclaim_comments,[
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_PROGRAM([],[! This is a comment])
|
|
],[
|
|
pac_cv_prog_f77_exclaim_comments="yes"
|
|
],[
|
|
pac_cv_prog_f77_exclaim_comments="no"
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
])
|
|
if test "$pac_cv_prog_f77_exclaim_comments" = "yes" ; then
|
|
ifelse([$1],[],[:],[$1])
|
|
else
|
|
ifelse([$2],[],[:],[$2])
|
|
fi
|
|
])dnl
|
|
dnl
|
|
dnl/*D
|
|
dnl PAC_F77_CHECK_COMPILER_OPTION - Check that a F77 compiler option is
|
|
dnl accepted without warning messages
|
|
dnl
|
|
dnl Synopsis:
|
|
dnl PAC_F77_CHECK_COMPILER_OPTION(optionname,action-if-ok,action-if-fail)
|
|
dnl
|
|
dnl Output Effects:
|
|
dnl
|
|
dnl If no actions are specified, a working value is added to 'FOPTIONS'
|
|
dnl
|
|
dnl Notes:
|
|
dnl This is now careful to check that the output is different, since
|
|
dnl some compilers are noisy.
|
|
dnl
|
|
dnl We are extra careful to prototype the functions in case compiler options
|
|
dnl that complain about poor code are in effect.
|
|
dnl
|
|
dnl Because this is a long script, we have ensured that you can pass a
|
|
dnl variable containing the option name as the first argument.
|
|
dnl D*/
|
|
AC_DEFUN([PAC_F77_CHECK_COMPILER_OPTION],[
|
|
AC_MSG_CHECKING([whether Fortran 77 compiler accepts option $1])
|
|
pac_opt="$1"
|
|
AC_LANG_PUSH([Fortran 77])
|
|
FFLAGS_orig="$FFLAGS"
|
|
FFLAGS_opt="$pac_opt $FFLAGS"
|
|
pac_result="unknown"
|
|
|
|
AC_LANG_CONFTEST([AC_LANG_PROGRAM()])
|
|
FFLAGS="$FFLAGS_orig"
|
|
rm -f pac_test1.log
|
|
PAC_LINK_IFELSE_LOG([pac_test1.log], [], [
|
|
FFLAGS="$FFLAGS_opt"
|
|
rm -f pac_test2.log
|
|
PAC_LINK_IFELSE_LOG([pac_test2.log], [], [
|
|
PAC_RUNLOG_IFELSE([diff -b pac_test1.log pac_test2.log],
|
|
[pac_result=yes], [pac_result=no])
|
|
],[
|
|
pac_result=no
|
|
])
|
|
], [
|
|
pac_result=no
|
|
])
|
|
AC_MSG_RESULT([$pac_result])
|
|
dnl Delete the conftest created by AC_LANG_CONFTEST.
|
|
rm -f conftest.$ac_ext
|
|
#
|
|
if test "$pac_result" = "yes" ; then
|
|
AC_MSG_CHECKING([whether routines compiled with $pac_opt can be linked with ones compiled without $pac_opt])
|
|
pac_result=unknown
|
|
FFLAGS="$FFLAGS_orig"
|
|
rm -f pac_test3.log
|
|
PAC_COMPILE_IFELSE_LOG([pac_test3.log], [
|
|
AC_LANG_SOURCE([
|
|
subroutine try()
|
|
end
|
|
])
|
|
],[
|
|
PAC_RUNLOG([mv conftest.$OBJEXT pac_conftest.$OBJEXT])
|
|
saved_LIBS="$LIBS"
|
|
LIBS="pac_conftest.$OBJEXT $LIBS"
|
|
|
|
FFLAGS="$FFLAGS_opt"
|
|
rm -f pac_test4.log
|
|
PAC_LINK_IFELSE_LOG([pac_test4.log], [AC_LANG_PROGRAM()], [
|
|
PAC_RUNLOG_IFELSE([diff -b pac_test2.log pac_test4.log],
|
|
[pac_result=yes], [pac_result=no])
|
|
],[
|
|
pac_result=no
|
|
])
|
|
LIBS="$saved_LIBS"
|
|
rm -f pac_conftest.$OBJEXT
|
|
],[
|
|
pac_result=no
|
|
])
|
|
AC_MSG_RESULT([$pac_result])
|
|
rm -f pac_test3.log pac_test4.log
|
|
fi
|
|
rm -f pac_test1.log pac_test2.log
|
|
|
|
dnl Restore FFLAGS before 2nd/3rd argument commands are executed,
|
|
dnl as 2nd/3rd argument command could be modifying FFLAGS.
|
|
FFLAGS="$FFLAGS_orig"
|
|
if test "$pac_result" = "yes" ; then
|
|
ifelse([$2],[],[FOPTIONS="$FOPTIONS $1"],[$2])
|
|
else
|
|
ifelse([$3],[],[:],[$3])
|
|
fi
|
|
AC_LANG_POP([Fortran 77])
|
|
])
|
|
dnl
|
|
dnl/*D
|
|
dnl PAC_PROG_F77_LIBRARY_DIR_FLAG - Determine the flag used to indicate
|
|
dnl the directories to find libraries in
|
|
dnl
|
|
dnl Notes:
|
|
dnl Many compilers accept '-Ldir' just like most C compilers.
|
|
dnl Unfortunately, some (such as some HPUX Fortran compilers) do not,
|
|
dnl and require instead either '-Wl,-L,dir' or something else. This
|
|
dnl command attempts to determine what is accepted. The flag is
|
|
dnl placed into 'F77_LIBDIR_LEADER'.
|
|
dnl
|
|
dnl D*/
|
|
dnl
|
|
dnl An earlier version of this only tried the arguments without using
|
|
dnl a library. This failed when the HP compiler complained about the
|
|
dnl arguments, but produced an executable anyway.
|
|
AC_DEFUN([PAC_PROG_F77_LIBRARY_DIR_FLAG],[
|
|
AC_CACHE_CHECK([for Fortran 77 flag for library directories],
|
|
pac_cv_prog_f77_library_dir_flag,[
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
subroutine f1conf
|
|
end
|
|
])
|
|
],[
|
|
# pac_f77compile_ok=yes
|
|
PAC_RUNLOG([mv conftest.$OBJEXT pac_f77conftest.$OBJEXT])
|
|
PAC_RUNLOG([test -d conftestdir || mkdir conftestdir])
|
|
PAC_RUNLOG([${AR-ar} ${AR_FLAGS-cr} conftestdir/libf77conftest.a pac_f77conftest.$OBJEXT])
|
|
PAC_RUNLOG([${RANLIB-ranlib} conftestdir/libf77conftest.a])
|
|
# Save original LIBS, prepend previously generated object file to LIBS
|
|
saved_LIBS="$LIBS"
|
|
LIBS="-lf77conftest $LIBS"
|
|
saved_LDFLAGS="$LDFLAGS"
|
|
pac_cv_prog_f77_library_dir_flag="none"
|
|
for ldir in "-L" "-Wl,-L," ; do
|
|
LDFLAGS="${ldir}conftestdir $saved_LDFLAGS"
|
|
AC_LINK_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
program main
|
|
call f1conf
|
|
end
|
|
])
|
|
],[pac_cv_prog_f77_library_dir_flag="$ldir";break])
|
|
done
|
|
LDFLAGS="$saved_LDFLAGS"
|
|
LIBS="$saved_LIBS"
|
|
rm -rf conftestdir
|
|
rm -f pac_f77conftest.$OBJEXT
|
|
],[])
|
|
AC_LANG_POP([Fortran 77])
|
|
])
|
|
dnl Endof ac_cache_check
|
|
if test "X$pac_cv_prog_f77_library_dir_flag" != "Xnone" ; then
|
|
F77_LIBDIR_LEADER="$pac_cv_prog_f77_library_dir_flag"
|
|
AC_SUBST(F77_LIBDIR_LEADER)
|
|
fi
|
|
])
|
|
dnl
|
|
dnl/*D
|
|
dnl PAC_PROG_F77_HAS_INCDIR - Check whether Fortran accepts -Idir flag
|
|
dnl
|
|
dnl Syntax:
|
|
dnl PAC_PROG_F77_HAS_INCDIR(directory,action-if-true,action-if-false)
|
|
dnl
|
|
dnl Output Effect:
|
|
dnl Sets 'F77_INCDIR' to the flag used to choose the directory.
|
|
dnl
|
|
dnl Notes:
|
|
dnl This refers to the handling of the common Fortran include extension,
|
|
dnl not to the use of '#include' with the C preprocessor.
|
|
dnl If directory does not exist, it will be created. In that case, the
|
|
dnl directory should be a direct descendant of the current directory.
|
|
dnl
|
|
dnl D*/
|
|
AC_DEFUN([PAC_PROG_F77_HAS_INCDIR],[
|
|
ifelse([$1],[],[checkdir=f77tmpdir],[checkdir=$1;checkdir_is_given=yes])
|
|
AC_CACHE_CHECK([for include directory flag for Fortran],
|
|
pac_cv_prog_f77_has_incdir,[
|
|
test -d $checkdir || mkdir $checkdir
|
|
dnl PAC_RUNLOG([echo ' call sub()' > $checkdir/conftestf.h])
|
|
echo ' call sub()' > $checkdir/conftestf.h
|
|
AC_LANG_PUSH([Fortran 77])
|
|
saved_FFLAGS="$FFLAGS"
|
|
pac_cv_prog_f77_has_incdir="none"
|
|
# SGI wants -Wf,-I
|
|
for idir in "-I" "-Wf,-I" ; do
|
|
FFLAGS="${idir} $checkdir $saved_FFLAGS"
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
program main
|
|
include 'conftestf.h'
|
|
end
|
|
])
|
|
],[pac_cv_prog_f77_has_incdir="$idir"; break])
|
|
done
|
|
FFLAGS="$saved_FFLAGS"
|
|
AC_LANG_POP([Fortran 77])
|
|
if test "$checkdir_is_given" = "yes" ; then
|
|
rm -f $checkdir/conftestf.h
|
|
else
|
|
rm -rf $checkdir
|
|
fi
|
|
])
|
|
dnl Endof ac_cache_check
|
|
if test "X$pac_cv_prog_f77_has_incdir" != "Xnone" ; then
|
|
F77_INCDIR="$pac_cv_prog_f77_has_incdir"
|
|
AC_SUBST(F77_INCDIR)
|
|
fi
|
|
])
|
|
dnl
|
|
dnl/*D
|
|
dnl PAC_PROG_F77_ALLOWS_UNUSED_EXTERNALS - Check whether the Fortran compiler
|
|
dnl allows unused and undefined functions to be listed in an external
|
|
dnl statement
|
|
dnl
|
|
dnl Syntax:
|
|
dnl PAC_PROG_F77_ALLOWS_UNUSED_EXTERNALS(action-if-true,action-if-false)
|
|
dnl
|
|
dnl D*/
|
|
AC_DEFUN([PAC_PROG_F77_ALLOWS_UNUSED_EXTERNALS],[
|
|
AC_CACHE_CHECK([whether Fortran allows unused externals],
|
|
pac_cv_prog_f77_allows_unused_externals,[
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_LINK_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
program main
|
|
external bar
|
|
end
|
|
])
|
|
],[
|
|
pac_cv_prog_f77_allows_unused_externals="yes"
|
|
],[
|
|
pac_cv_prog_f77_allows_unused_externals="no"
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
])
|
|
dnl Endof ac_cache_check
|
|
if test "X$pac_cv_prog_f77_allows_unused_externals" = "Xyes" ; then
|
|
ifelse([$1],[],[:],[$1])
|
|
else
|
|
ifelse([$2],[],[:],[$2])
|
|
fi
|
|
])
|
|
dnl PAC_PROG_F77_RUN_PROC_FROM_C( c main program, fortran routine,
|
|
dnl [action-if-works], [action-if-fails],
|
|
dnl [cross-action] )
|
|
dnl Fortran routine MUST be named ftest unless you include code
|
|
dnl to select the appropriate Fortran name.
|
|
dnl
|
|
AC_DEFUN([PAC_PROG_F77_RUN_PROC_FROM_C],[
|
|
AC_REQUIRE([AC_HEADER_STDC])
|
|
AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_SOURCE([$2])
|
|
],[
|
|
# pac_f77compile_ok=yes
|
|
PAC_RUNLOG([mv conftest.$OBJEXT pac_f77conftest.$OBJEXT])
|
|
# Save original LIBS, prepend previously generated object file to LIBS
|
|
saved_LIBS="$LIBS"
|
|
LIBS="pac_f77conftest.$OBJEXT $FLIBS $LIBS"
|
|
AC_LANG_PUSH([C])
|
|
AC_RUN_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
#if defined(HAVE_STDIO_H) || defined(STDC_HEADERS)
|
|
#include <stdio.h>
|
|
#endif
|
|
#ifdef F77_NAME_UPPER
|
|
#define ftest_ FTEST
|
|
#elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED)
|
|
#define ftest_ ftest
|
|
#endif
|
|
$1
|
|
])
|
|
],[
|
|
ifelse([$3],[],[:],[$3])
|
|
],[
|
|
ifelse([$4],[],[:],[$4])
|
|
],[
|
|
ifelse([$5],[],[:],[$5])
|
|
])
|
|
AC_LANG_POP([C])
|
|
LIBS="$saved_LIBS"
|
|
rm -f pac_f77conftest.$OBJEXT
|
|
],[
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
])
|
|
dnl PAC_PROG_F77_IN_C_LIBS
|
|
dnl
|
|
dnl Find the essential libraries that are needed to use the C linker to
|
|
dnl create a program that includes a trival Fortran code.
|
|
dnl
|
|
dnl For example, all pgf90 compiled objects include a reference to the
|
|
dnl symbol pgf90_compiled, found in libpgf90 .
|
|
dnl
|
|
dnl There is an additional problem. To *run* programs, we may need
|
|
dnl additional arguments; e.g., if shared libraries are used. Even
|
|
dnl with autoconf 2.52, the autoconf macro to find the library arguments
|
|
dnl doesn't handle this, either by detecting the use of -rpath or
|
|
dnl by trying to *run* a trivial program. It only checks for *linking*.
|
|
dnl
|
|
dnl
|
|
AC_DEFUN([PAC_PROG_F77_IN_C_LIBS],[
|
|
AC_REQUIRE([AC_HEADER_STDC])
|
|
AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])
|
|
AC_MSG_CHECKING([for which Fortran libraries are needed to link C with Fortran])
|
|
F77_IN_C_LIBS="invalid"
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
subroutine ftest
|
|
end
|
|
])
|
|
],[
|
|
# pac_f77compile_ok=yes
|
|
PAC_RUNLOG([mv conftest.$OBJEXT pac_f77conftest.$OBJEXT])
|
|
# Save original LIBS, prepend previously generated object file to LIBS
|
|
saved_LIBS="$LIBS"
|
|
LIBS="pac_f77conftest.$OBJEXT $FLIBS $saved_LIBS"
|
|
AC_LANG_PUSH([C])
|
|
|
|
# Create conftest for all link tests.
|
|
AC_LANG_CONFTEST([
|
|
AC_LANG_PROGRAM([
|
|
#if defined(HAVE_STDIO_H) || defined(STDC_HEADERS)
|
|
#include <stdio.h>
|
|
#endif
|
|
],[
|
|
#ifdef F77_NAME_UPPER
|
|
#define ftest_ FTEST
|
|
#elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED)
|
|
#define ftest_ ftest
|
|
#endif
|
|
extern void ftest_(void);
|
|
ftest_();
|
|
])
|
|
])
|
|
|
|
F77_IN_C_LIBS=""
|
|
AC_LINK_IFELSE([],[:],[
|
|
flibdirs=`echo $FLIBS | tr ' ' '\012' | grep '\-L' | tr '\012' ' '`
|
|
fliblibs=`echo $FLIBS | tr ' ' '\012' | grep -v '\-L' | tr '\012' ' '`
|
|
for flibs in $fliblibs ; do
|
|
LIBS="pac_f77conftest.$OBJEXT $flibdirs $flibs $saved_LIBS"
|
|
AC_LINK_IFELSE([],[F77_IN_C_LIBS="$flibdirs $flibs"; break])
|
|
done
|
|
if test "X$F77_IN_C_LIBS" = "X" ; then
|
|
flibscat=""
|
|
for flibs in $fliblibs ; do
|
|
flibscat="$flibscat $flibs"
|
|
LIBS="pac_f77conftest.$OBJEXT $flibdirs $flibscat $saved_LIBS"
|
|
AC_LINK_IFELSE([],[F77_IN_C_LIBS="$flibdirs $flibscat";break])
|
|
done
|
|
fi
|
|
])
|
|
|
|
# remove conftest created by ac_lang_conftest
|
|
rm -f conftest.$ac_ext
|
|
AC_LANG_POP([C])
|
|
LIBS="$saved_LIBS"
|
|
rm -f pac_f77conftest.$OBJEXT
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
if test "X$F77_IN_C_LIBS" = "X" ; then
|
|
AC_MSG_RESULT(none)
|
|
else
|
|
AC_MSG_RESULT($F77_IN_C_LIBS)
|
|
fi
|
|
])
|
|
dnl
|
|
dnl Test to see if we should use C or Fortran to link programs whose
|
|
dnl main program is in Fortran. We may find that neither work because
|
|
dnl we need special libraries in each case.
|
|
dnl
|
|
AC_DEFUN([PAC_PROG_F77_LINKER_WITH_C],[
|
|
AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])
|
|
AC_MSG_CHECKING([for linker for Fortran main program])
|
|
dnl Create a C program that uses multiplication and division
|
|
dnl in case that requires special libraries
|
|
AC_LANG_PUSH([C])
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_PROGRAM([],[long long a;])
|
|
],[
|
|
AC_DEFINE(HAVE_LONG_LONG,1,[Define if long long allowed])
|
|
])
|
|
AC_LANG_CONFTEST([
|
|
AC_LANG_SOURCE([
|
|
#ifdef HAVE_LONG_LONG
|
|
int f(int a, long long b) { int c; c = a * ( b / 3 ) / (b-1); return c ; }
|
|
#else
|
|
int f(int a, long b) { int c; c = a * b / (b-1); return c ; }
|
|
#endif
|
|
])
|
|
])
|
|
AC_LANG_POP([C])
|
|
|
|
dnl Create a Fortran program for test
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_LANG_CONFTEST([
|
|
AC_LANG_SOURCE([
|
|
program main
|
|
double precision d
|
|
print *, "hi"
|
|
end
|
|
])
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
|
|
dnl Initialize flags
|
|
pac_linkwithf77=no
|
|
pac_linkwithC=no
|
|
|
|
dnl Use F77 as a linker to compile a Fortran main and C subprogram.
|
|
if test "$pac_linkwithC" != "yes" ; then
|
|
AC_LANG_PUSH([C])
|
|
AC_COMPILE_IFELSE([],[
|
|
PAC_RUNLOG([mv conftest.$OBJEXT pac_conftest.$OBJEXT])
|
|
saved_LIBS="$LIBS"
|
|
LIBS="pac_conftest.$OBJEXT $saved_LIBS"
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_LINK_IFELSE([],[
|
|
AC_MSG_RESULT([Use Fortran to link programs])
|
|
pac_linkwithf77=yes
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
LIBS="$saved_LIBS"
|
|
rm -f pac_conftest.$OBJEXT
|
|
])
|
|
AC_LANG_POP([C])
|
|
fi
|
|
|
|
dnl Use C as a linker and FLIBS to compile a Fortran main and C subprogram.
|
|
if test "$pac_linkwithf77" != "yes" ; then
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_COMPILE_IFELSE([],[
|
|
PAC_RUNLOG([mv conftest.$OBJEXT pac_f77conftest.$OBJEXT])
|
|
saved_LIBS="$LIBS"
|
|
LIBS="pac_f77conftest.$OBJEXT $FLIBS $saved_LIBS"
|
|
AC_LANG_PUSH([C])
|
|
AC_LINK_IFELSE([],[
|
|
pac_linkwithC=yes
|
|
AC_MSG_RESULT([Use C with FLIBS to link programs])
|
|
F77LINKER="$CC"
|
|
F77_LDFLAGS="$F77_LDFLAGS $FLIBS"
|
|
])
|
|
AC_LANG_POP([C])
|
|
LIBS="$saved_LIBS"
|
|
rm -f pac_f77conftest.$OBJEXT
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
fi
|
|
|
|
AC_LANG_PUSH([Fortran 77])
|
|
rm -f conftest.$ac_ext
|
|
AC_LANG_POP([Fortran 77])
|
|
|
|
AC_LANG_PUSH([C])
|
|
rm -f conftest.$ac_ext
|
|
AC_LANG_POP([C])
|
|
|
|
if test "$pac_linkwithf77" != "yes" -a "$pac_linkwithC" != "yes" ; then
|
|
AC_MSG_ERROR([Could not determine a way to link a Fortran test program!])
|
|
fi
|
|
])
|
|
dnl
|
|
dnl Check to see if a C program can be linked when using the libraries
|
|
dnl needed by C programs
|
|
dnl
|
|
AC_DEFUN([PAC_PROG_F77_CHECK_FLIBS],[
|
|
AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])
|
|
AC_MSG_CHECKING([whether $CC links with FLIBS found by autoconf])
|
|
AC_LANG_PUSH([C])
|
|
# Create a simple C program for the tests.
|
|
AC_LANG_CONFTEST([
|
|
AC_LANG_PROGRAM([],[int a;])
|
|
])
|
|
# Try to link a C program with all of these libraries
|
|
saved_LIBS="$LIBS"
|
|
LIBS="$FLIBS $saved_LIBS"
|
|
AC_LINK_IFELSE([],[
|
|
AC_MSG_RESULT([yes])
|
|
],[
|
|
AC_MSG_RESULT([no])
|
|
AC_MSG_CHECKING([for which libraries can be used])
|
|
pac_ldirs=""
|
|
pac_libs=""
|
|
pac_other=""
|
|
for name in $FLIBS ; do
|
|
case $name in
|
|
-l*) pac_libs="$pac_libs $name" ;;
|
|
-L*) pac_ldirs="$pac_ldirs $name" ;;
|
|
*) pac_other="$pac_other $name" ;;
|
|
esac
|
|
done
|
|
keep_libs=""
|
|
for name in $pac_libs ; do
|
|
LIBS="$saved_LIBS $pac_ldirs $pac_other $name"
|
|
AC_LINK_IFELSE([],[
|
|
keep_libs="$keep_libs $name"
|
|
])
|
|
done
|
|
AC_MSG_RESULT($keep_libs)
|
|
FLIBS="$pac_ldirs $pac_other $keep_libs"
|
|
])
|
|
LIBS="$saved_LIBS"
|
|
rm -f conftest.$ac_ext
|
|
AC_LANG_PUSH([C])
|
|
])
|
|
dnl
|
|
dnl Test for extra libraries needed when linking C routines that use
|
|
dnl stdio with Fortran. This test was created for OSX, which
|
|
dnl sometimes requires -lSystemStubs. If another library is needed,
|
|
dnl add it to F77_OTHER_LIBS
|
|
dnl
|
|
AC_DEFUN([PAC_PROG_F77_AND_C_STDIO_LIBS],[
|
|
AC_REQUIRE([AC_HEADER_STDC])
|
|
AC_REQUIRE([PAC_PROG_F77_NAME_MANGLE])
|
|
# To simply the code in the cache_check macro, chose the routine name
|
|
# first, in case we need it
|
|
confname=conf1_
|
|
case "$pac_cv_prog_f77_name_mangle" in
|
|
"lower underscore") confname=conf1_ ;;
|
|
"upper stdcall") confname=CONF1 ;;
|
|
"upper") confname=CONF1 ;;
|
|
"lower doubleunderscore") confname=conf1_ ;;
|
|
"lower") confname=conf1 ;;
|
|
"mixed underscore") confname=conf1_ ;;
|
|
"mixed") confname=conf1 ;;
|
|
esac
|
|
|
|
AC_CACHE_CHECK([for libraries to link Fortran main with C stdio routines],
|
|
pac_cv_prog_f77_and_c_stdio_libs,[
|
|
pac_cv_prog_f77_and_c_stdio_libs=unknown
|
|
AC_LANG_PUSH([C])
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
#if defined(HAVE_STDIO_H) || defined(STDC_HEADERS)
|
|
#include <stdio.h>
|
|
#endif
|
|
int $confname(int a) {
|
|
printf( "The answer is %d\n", a ); fflush(stdout); return 0;
|
|
}
|
|
])
|
|
],[
|
|
PAC_RUNLOG([mv conftest.$OBJEXT pac_conftest.$OBJEXT])
|
|
saved_LIBS="$LIBS"
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_LANG_CONFTEST([
|
|
AC_LANG_SOURCE([
|
|
program main
|
|
call conf1(0)
|
|
end
|
|
])
|
|
])
|
|
for extralib in "" "-lSystemStubs" ; do
|
|
LIBS="pac_conftest.$OBJEXT $saved_LIBS $extralib"
|
|
AC_LINK_IFELSE([],[
|
|
pac_cv_prog_f77_and_c_stdio_libs="$extralib"; break
|
|
])
|
|
done
|
|
if test "X$pac_cv_prog_f77_and_c_stdio_libs" = "X" ; then
|
|
pac_cv_prog_f77_and_c_stdio_libs=none
|
|
fi
|
|
rm -f conftest.$ac_ext
|
|
AC_LANG_POP([Fortran 77])
|
|
LIBS="$saved_LIBS"
|
|
rm -f pac_conftest.$OBJEXT
|
|
])
|
|
AC_LANG_POP([C])
|
|
])
|
|
dnl Endof ac_cache_check
|
|
if test "$pac_cv_prog_f77_and_c_stdio_libs" != "none" \
|
|
-a "$pac_cv_prog_f77_and_c_stdio_libs" != "unknown" ; then
|
|
F77_OTHER_LIBS="$F77_OTHER_LIBS $pac_cv_prog_f77_and_c_stdio_libs"
|
|
fi
|
|
])
|
|
dnl
|
|
dnl Check that the FLIBS determined by AC_F77_LIBRARY_LDFLAGS is valid.
|
|
dnl That macro (at least as of autoconf 2.59) attempted to parse the output
|
|
dnl of the compiler when asked to be verbose; in the case of the Fujitsu
|
|
dnl frt Fortran compiler, it included files that frt looked for and then
|
|
dnl discarded because they did not exist.
|
|
dnl
|
|
AC_DEFUN([PAC_PROG_F77_FLIBS_VALID],[
|
|
AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])
|
|
AC_MSG_CHECKING([whether $F77 accepts the FLIBS found by autoconf])
|
|
pac_cv_f77_flibs_valid=unknown
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_LANG_CONFTEST([
|
|
AC_LANG_SOURCE([
|
|
program main
|
|
end
|
|
])
|
|
])
|
|
AC_LINK_IFELSE([],[
|
|
AC_MSG_RESULT([yes])
|
|
],[
|
|
AC_MSG_RESULT([no])
|
|
AC_MSG_CHECKING([for valid entries in FLIBS])
|
|
goodFLIBS=""
|
|
saveFLIBS=$FLIBS
|
|
FLIBS=""
|
|
for arg in $saveFLIBS ; do
|
|
FLIBS="$goodFLIBS $arg"
|
|
AC_LINK_IFELSE([],[goodFLIBS=$FLIBS])
|
|
done
|
|
FLIBS=$goodFLIBS
|
|
AC_MSG_RESULT($FLIBS)
|
|
])
|
|
rm -f conftest.$ac_ext
|
|
AC_LANG_POP([Fortran 77])
|
|
])
|
|
dnl
|
|
dnl Check if the Fortran 77 and C objects are compatible in linking.
|
|
dnl e.g. On some intel x86_64 Mac, Fortran compiler's default binary format
|
|
dnl is different from C, so either -m64 or -m32 is needed in either CFLAGS
|
|
dnl or FFLAGS.
|
|
dnl
|
|
AC_DEFUN([PAC_PROG_F77_OBJ_LINKS_WITH_C],[
|
|
AC_REQUIRE([AC_F77_LIBRARY_LDFLAGS])
|
|
AC_MSG_CHECKING([whether Fortran 77 and C objects are compatible])
|
|
AC_LANG_PUSH([C])
|
|
AC_LANG_CONFTEST([
|
|
AC_LANG_SOURCE([
|
|
/* lower */
|
|
void c_subpgm( int *rc );
|
|
void c_subpgm( int *rc ) { *rc = 1; }
|
|
|
|
/* lower underscore */
|
|
void c_subpgm_( int *rc );
|
|
void c_subpgm_( int *rc ) { *rc = 2; }
|
|
|
|
/* upper */
|
|
void C_SUBPGM( int *rc );
|
|
void C_SUBPGM( int *rc ) { *rc = 3; }
|
|
|
|
/* lower doubleunderscore */
|
|
void c_subpgm__( int *rc );
|
|
void c_subpgm__( int *rc ) { *rc = 4; }
|
|
|
|
/* mixed */
|
|
void C_subpgm( int *rc );
|
|
void C_subpgm( int *rc ) { *rc = 5; }
|
|
|
|
/* mixed underscore */
|
|
void C_subpgm_( int *rc );
|
|
void C_subpgm_( int *rc ) { *rc = 6; }
|
|
])
|
|
])
|
|
AC_LANG_POP([C])
|
|
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_LANG_CONFTEST([
|
|
AC_LANG_SOURCE([
|
|
program test
|
|
integer rc
|
|
rc = -1
|
|
call c_subpgm( rc )
|
|
write(6,*) "rc=", rc
|
|
end
|
|
])
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
|
|
dnl Initialize flags
|
|
pac_linkwithf77=no
|
|
pac_linkwithC=no
|
|
|
|
dnl Use F77 as a linker to compile a Fortran main and C subprogram.
|
|
if test "$pac_linkwithC" != "yes" ; then
|
|
AC_LANG_PUSH([C])
|
|
AC_COMPILE_IFELSE([],[
|
|
PAC_RUNLOG([mv conftest.$OBJEXT pac_conftest.$OBJEXT])
|
|
saved_LIBS="$LIBS"
|
|
LIBS="pac_conftest.$OBJEXT $saved_LIBS"
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_LINK_IFELSE([],[
|
|
pac_linkwithf77=yes
|
|
AC_MSG_RESULT([yes])
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
LIBS="$saved_LIBS"
|
|
if test "$pac_linkwithf77" = "yes" ; then
|
|
rm -f pac_conftest.$OBJEXT
|
|
fi
|
|
])
|
|
AC_LANG_POP([C])
|
|
fi
|
|
|
|
dnl Use C as a linker and FLIBS to compile a Fortran main and C subprogram.
|
|
if test "$pac_linkwithf77" != "yes" ; then
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_COMPILE_IFELSE([],[
|
|
PAC_RUNLOG([mv conftest.$OBJEXT pac_f77conftest.$OBJEXT])
|
|
saved_LIBS="$LIBS"
|
|
LIBS="pac_f77conftest.$OBJEXT $FLIBS $saved_LIBS"
|
|
AC_LANG_PUSH([C])
|
|
AC_LINK_IFELSE([],[
|
|
pac_linkwithC=yes
|
|
AC_MSG_RESULT([yes])
|
|
])
|
|
AC_LANG_POP([C])
|
|
LIBS="$saved_LIBS"
|
|
if test "$pac_linkwithC" = "yes" ; then
|
|
rm -f pac_f77conftest.$OBJEXT
|
|
fi
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
fi
|
|
|
|
AC_LANG_PUSH([Fortran 77])
|
|
rm -f conftest.$ac_ext
|
|
AC_LANG_POP([Fortran 77])
|
|
|
|
AC_LANG_PUSH([C])
|
|
rm -f conftest.$ac_ext
|
|
AC_LANG_POP([C])
|
|
|
|
if test "$pac_linkwithf77" != "yes" -a "$pac_linkwithC" != "yes" ; then
|
|
AC_MSG_RESULT(no)
|
|
AC_CHECK_PROG(FILE, file, file, [])
|
|
if test "X$FILE" != "X" ; then
|
|
fobjtype="`${FILE} pac_f77conftest.$OBJEXT | sed -e \"s|pac_f77conftest\.$OBJEXT||g\"`"
|
|
cobjtype="`${FILE} pac_conftest.$OBJEXT | sed -e \"s|pac_conftest\.$OBJEXT||g\"`"
|
|
if test "$fobjtype" != "$cobjtype" ; then
|
|
AC_MSG_ERROR([**** Incompatible Fortran and C Object File Types! ****
|
|
F77 Object File Type produced by \"${F77} ${FFLAGS}\" is : ${fobjtype}.
|
|
C Object File Type produced by \"${CC} ${CFLAGS}\" is : ${cobjtype}.])
|
|
fi
|
|
fi
|
|
fi
|
|
])
|
|
dnl
|
|
dnl /*D
|
|
dnl PAC_F77_WORKS_WITH_CPP
|
|
dnl
|
|
dnl Checks if Fortran 77 compiler works with C preprocessor
|
|
dnl
|
|
dnl Most systems allow the Fortran compiler to process .F and .F90 files
|
|
dnl using the C preprocessor. However, some systems either do not
|
|
dnl allow this or have serious bugs (OSF Fortran compilers have a bug
|
|
dnl that generates an error message from cpp). The following test
|
|
dnl checks to see if .F works, and if not, whether "cpp -P -C" can be used
|
|
dnl D*/
|
|
AC_DEFUN([PAC_F77_WORKS_WITH_CPP],[
|
|
AC_REQUIRE([AC_PROG_CPP])
|
|
AC_MSG_CHECKING([whether Fortran 77 compiler processes .F files with C preprocessor])
|
|
AC_LANG_PUSH([Fortran 77])
|
|
saved_f77_ext=${ac_ext}
|
|
ac_ext="F"
|
|
saved_FFLAGS="$FFLAGS"
|
|
FFLAGS="$FFLAGS $CPPFLAGS"
|
|
AC_LANG_CONFTEST([
|
|
AC_LANG_SOURCE([
|
|
program main
|
|
#define ASIZE 10
|
|
integer a(ASIZE)
|
|
end
|
|
])
|
|
])
|
|
AC_COMPILE_IFELSE([],[
|
|
pac_cv_f77_accepts_F=yes
|
|
ifelse([$1],[],[],[$1=""])
|
|
],[
|
|
pac_cv_f77_accepts_F=no
|
|
ifelse([$1],[],[:],[$1="false"])
|
|
])
|
|
# Restore Fortran 77's ac_ext but not FFLAGS
|
|
ac_ext="$saved_f77_ext"
|
|
|
|
if test "$pac_cv_f77_accepts_F" != "yes" ; then
|
|
pac_cpp_f77="$ac_cpp -C -P conftest.F > conftest.$ac_ext"
|
|
PAC_RUNLOG_IFELSE([$pac_cpp_f77],[
|
|
if test -s conftest.${ac_ext} ; then
|
|
AC_COMPILE_IFELSE([],[
|
|
pac_cv_f77_accepts_F="no, use cpp"
|
|
ifelse([$1],[],[],[$1="$CPP -C -P"])
|
|
],[])
|
|
rm -f conftest.${ac_ext}
|
|
fi
|
|
],[])
|
|
fi
|
|
FFLAGS="$saved_FFLAGS"
|
|
rm -f conftest.F
|
|
AC_LANG_POP([Fortran 77])
|
|
AC_MSG_RESULT([$pac_cv_f77_accepts_F])
|
|
])
|
|
dnl
|
|
dnl /*D
|
|
dnl PAC_PROG_F77_CRAY_POINTER - Check if Fortran 77 supports Cray-style pointer.
|
|
dnl If so, set pac_cv_prog_f77_has_pointer to yes
|
|
dnl and find out if any extra compiler flag is
|
|
dnl needed and set it as CRAYPTR_FFLAGS.
|
|
dnl i.e. CRAYPTR_FFLAGS is meaningful only if
|
|
dnl pac_cv_prog_f77_has_pointer = yes.
|
|
dnl
|
|
dnl Synopsis:
|
|
dnl PAC_PROG_F77_CRAY_POINTER([action-if-true],[action-if-false])
|
|
dnl D*/
|
|
AC_DEFUN([PAC_PROG_F77_CRAY_POINTER],[
|
|
AC_CACHE_CHECK([whether Fortran 77 supports Cray-style pointer],
|
|
pac_cv_prog_f77_has_pointer,[
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_LANG_CONFTEST([
|
|
AC_LANG_PROGRAM([],[
|
|
integer M
|
|
pointer (MPTR,M)
|
|
data MPTR/0/
|
|
])
|
|
])
|
|
saved_FFLAGS="$FFLAGS"
|
|
pac_cv_prog_f77_has_pointer=no
|
|
CRAYPTR_FFLAGS=""
|
|
for ptrflag in '' '-fcray-pointer' ; do
|
|
FFLAGS="$saved_FFLAGS $ptrflag"
|
|
AC_COMPILE_IFELSE([], [
|
|
pac_cv_prog_f77_has_pointer=yes
|
|
CRAYPTR_FFLAGS="$ptrflag"
|
|
break
|
|
])
|
|
done
|
|
dnl Restore FFLAGS first, since user may not want to modify FFLAGS
|
|
FFLAGS="$saved_FFLAGS"
|
|
dnl remove conftest after ac_lang_conftest
|
|
rm -f conftest.$ac_ext
|
|
AC_LANG_POP([Fortran 77])
|
|
])
|
|
if test "$pac_cv_prog_f77_has_pointer" = "yes" ; then
|
|
AC_MSG_CHECKING([for Fortran 77 compiler flag for Cray-style pointer])
|
|
if test "X$CRAYPTR_FFLAGS" != "X" ; then
|
|
AC_MSG_RESULT([$CRAYPTR_FFLAGS])
|
|
else
|
|
AC_MSG_RESULT([none])
|
|
fi
|
|
ifelse([$1],[],[:],[$1])
|
|
else
|
|
ifelse([$2],[],[:],[$2])
|
|
fi
|
|
])
|
|
dnl
|
|
dnl
|
|
dnl PAC_F77_INIT_WORKS_WITH_C
|
|
dnl
|
|
AC_DEFUN([PAC_F77_INIT_WORKS_WITH_C],[
|
|
AC_REQUIRE([AC_HEADER_STDC])
|
|
AC_MSG_CHECKING([whether Fortran init will work with C])
|
|
pac_f_init_works_with_c=unknown
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
subroutine minit()
|
|
common /m1/ vc, vc2
|
|
character*1 vc(1,1), vc2(1)
|
|
common /m2/ vd
|
|
integer vd
|
|
save /m1/, /m2/
|
|
call minitc( vc, vc2, vd )
|
|
end
|
|
])
|
|
],[
|
|
PAC_RUNLOG([mv conftest.$OBJEXT pac_f77conftest.$OBJEXT])
|
|
saved_LIBS="$LIBS"
|
|
# This test checks if Fortran init can be done in pure C environment,
|
|
# i.e. no FLIBS in linking, so don't put FLIBS in LIBS below
|
|
dnl LIBS="pac_f77conftest.$OBJEXT $FLIBS $LIBS"
|
|
LIBS="pac_f77conftest.$OBJEXT $LIBS"
|
|
AC_LANG_PUSH([C])
|
|
AC_LINK_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
#if defined(HAVE_STDIO_H) || defined(STDC_HEADERS)
|
|
#include <stdio.h>
|
|
#endif
|
|
#ifdef F77_NAME_UPPER
|
|
#define minit_ MINIT
|
|
#elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED)
|
|
#define minit_ minit
|
|
#endif
|
|
extern void minit_(void);
|
|
int main( int argc, char **argv )
|
|
{
|
|
minit_();
|
|
return 0;
|
|
}
|
|
char *v1 = 0;
|
|
char *vc2 = 0;
|
|
int v2 = 0;
|
|
void minitc_( char *dv1, int d, char *dv2, int d2, int dv3 );
|
|
void minitc_( char *dv1, int d, char *dv2, int d2, int dv3 )
|
|
{
|
|
v1 = dv1;
|
|
v2 = dv3;
|
|
vc2 = dv2;
|
|
*vc2 = ' ';
|
|
}
|
|
])
|
|
],[pac_f_init_works_with_c=yes],[pac_f_init_works_with_c=no])
|
|
AC_LANG_POP([C])
|
|
LIBS="$saved_LIBS"
|
|
rm -f pac_f77conftest.$OBJEXT
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
AC_MSG_RESULT([$pac_f_init_works_with_c])
|
|
])
|
|
dnl
|
|
dnl PAC_F77_LOGICALS_IN_C(MPI_FINT)
|
|
dnl
|
|
dnl where MPI_FINT is the C type for Fortran integer.
|
|
dnl
|
|
dnl Use a Fortran main program. This simplifies some steps,
|
|
dnl since getting all of the Fortran libraries (including shared
|
|
dnl libraries that are not in the default library search path) can
|
|
dnl be tricky. Specifically, The PROG_F77_RUN_PROC_FROM_C failed with
|
|
dnl some installations of the Portland group compiler.
|
|
dnl
|
|
dnl We'd also like to check other values for .TRUE. and .FALSE. to see
|
|
dnl if the compiler allows (or uses) more than one value (some DEC compilers,
|
|
dnl for example, used the high (sign) bit to indicate true and false; the
|
|
dnl rest of the bits were ignored. For now, we'll assume that there are
|
|
dnl unique true and false values.
|
|
dnl
|
|
AC_DEFUN([PAC_F77_LOGICALS_IN_C],[
|
|
AC_REQUIRE([AC_HEADER_STDC])
|
|
AC_REQUIRE([PAC_PROG_F77_NAME_MANGLE])
|
|
pac_mpi_fint="$1"
|
|
AC_MSG_CHECKING([for values of Fortran logicals])
|
|
AC_CACHE_VAL(pac_cv_prog_f77_true_false_value,[
|
|
pac_cv_prog_f77_true_false_value=""
|
|
AC_LANG_PUSH([C])
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
#if defined(HAVE_STDIO_H) || defined(STDC_HEADERS)
|
|
#include <stdio.h>
|
|
#endif
|
|
#if defined(HAVE_STDLIB_H) || defined(STDC_HEADERS)
|
|
#include <stdlib.h>
|
|
#endif
|
|
#ifdef F77_NAME_UPPER
|
|
#define ftest_ FTEST
|
|
#elif defined(F77_NAME_LOWER) || defined(F77_NAME_MIXED)
|
|
#define ftest_ ftest
|
|
#endif
|
|
void ftest_( $pac_mpi_fint *, $pac_mpi_fint *);
|
|
void ftest_( $pac_mpi_fint *itrue, $pac_mpi_fint *ifalse )
|
|
{
|
|
FILE *f = fopen("conftestval","w");
|
|
if (!f) exit(1);
|
|
fprintf( f, "%d %d\n", *itrue, *ifalse );
|
|
fclose(f);
|
|
}
|
|
])
|
|
],[
|
|
PAC_RUNLOG([mv conftest.$OBJEXT pac_conftest.$OBJEXT])
|
|
saved_LIBS="$LIBS"
|
|
LIBS="pac_conftest.$OBJEXT $saved_LIBS"
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_RUN_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
program main
|
|
logical itrue, ifalse
|
|
itrue = .TRUE.
|
|
ifalse = .FALSE.
|
|
call ftest( itrue, ifalse )
|
|
end
|
|
])
|
|
],[
|
|
pac_cv_prog_f77_true_false_value="`cat conftestval`"
|
|
],[
|
|
AC_MSG_WARN([Failed to build/run program to determine Fortran logical values.])
|
|
],[
|
|
# Cross-Compiling. Allow the user to set the values
|
|
if test -n "$CROSS_F77_TRUE_VALUE" -a -n "$CROSS_F77_FALSE_VALUE" ; then
|
|
pac_cv_prog_f77_true_false_value="$CROSS_F77_TRUE_VALUE $CROSS_F77_FALSE_VALUE"
|
|
else
|
|
AC_MSG_WARN([Either CROSS_F77_TRUE_VALUE="$CROSS_F77_TRUE_VALUE" or CROSS_F77_FALSE_VALUE="$CROSS_F77_FALSE_VALUE" is not set.])
|
|
fi
|
|
])
|
|
AC_LANG_POP([Fortran 77])
|
|
LIBS="$saved_LIBS"
|
|
rm -f pac_conftest.$OBJEXT
|
|
])
|
|
AC_LANG_POP([C])
|
|
])
|
|
dnl Endof ac_cache_val
|
|
if test "X$pac_cv_prog_f77_true_false_value" != "X" ; then
|
|
true_val="`echo $pac_cv_prog_f77_true_false_value | sed -e 's/ .*//g'`"
|
|
false_val="`echo $pac_cv_prog_f77_true_false_value | sed -e 's/.* *//g'`"
|
|
if test -n "$true_val" -a -n "$false_val" ; then
|
|
AC_MSG_RESULT([True is $true_val and False is $false_val])
|
|
else
|
|
AC_MSG_RESULT([could not determine])
|
|
fi
|
|
fi
|
|
if test -n "$true_val" -a -n "$false_val" ; then
|
|
AC_DEFINE(F77_TRUE_VALUE_SET,1,[Define if we know the value of Fortran true and false])
|
|
AC_DEFINE_UNQUOTED(F77_TRUE_VALUE,$true_val,[The value of true in Fortran])
|
|
AC_DEFINE_UNQUOTED(F77_FALSE_VALUE,$false_val,[The value of false in Fortran])
|
|
fi
|
|
])
|
|
dnl/*D
|
|
dnl PAC_PROG_F77_MISMATCHED_ARGS([option],[AllOnly]) - Determine whether the
|
|
dnl Fortran compiler allows routines to be called with different
|
|
dnl argument types. If not, attempts to determine a command-line argument
|
|
dnl that permits such use
|
|
dnl (The Fortran standard prohibits this usage)
|
|
dnl
|
|
dnl option is set to the compiler option to use.
|
|
dnl if AllOnly is yes (literal, not variable with value), then only consider
|
|
dnl options that turn off checking
|
|
dnl for all routines
|
|
dnl
|
|
dnl The NAG Fortran compiler, nagfor, is known to enforce this part of the
|
|
dnl Fortran standard.
|
|
dnl D*/
|
|
AC_DEFUN([PAC_PROG_F77_MISMATCHED_ARGS],[
|
|
AC_MSG_CHECKING([whether $F77 allows mismatched arguments])
|
|
if test "X$pac_cv_prog_f77_mismatched_args" = X ; then
|
|
pac_cv_prog_f77_mismatched_args_parm=""
|
|
pac_cv_prog_f77_mismatched_args=no
|
|
AC_LANG_PUSH([Fortran 77])
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
program main
|
|
integer a
|
|
real b
|
|
character c
|
|
call foo1(a)
|
|
call foo1(b)
|
|
call foo1(c)
|
|
end
|
|
])],[pac_cv_prog_f77_mismatched_args=yes])
|
|
if test "$pac_cv_prog_f77_mismatched_args" != "yes" ; then
|
|
# try again with -wmismatch=foo1
|
|
save_FFLAGS="$FFLAGS"
|
|
# The best solution is to turn off errors on particular routines
|
|
# if that isn't possible (e.g., too many of them), then
|
|
# just try arguments that turn off all checking
|
|
for flags in ifelse($2,yes,,"-wmismatch=foo1") "-mismatch" ; do
|
|
testok=no
|
|
FFLAGS="$FFLAGS $flags"
|
|
AC_COMPILE_IFELSE([
|
|
AC_LANG_SOURCE([
|
|
program main
|
|
integer a
|
|
real b
|
|
character c
|
|
call foo1(a)
|
|
call foo1(b)
|
|
call foo1(c)
|
|
end
|
|
])],[testok=yes])
|
|
FFLAGS="$save_FFLAGS"
|
|
if test "$testok" = yes ; then break ; fi
|
|
done
|
|
if test "$testok" = yes ; then
|
|
pac_cv_prog_f77_mismatched_args_parm="$flags"
|
|
pac_cv_prog_f77_mismatched_args="yes, with $pac_cv_prog_f77_mismatched_args_parm"
|
|
fi
|
|
fi
|
|
AC_LANG_POP([Fortran 77])
|
|
fi
|
|
AC_MSG_RESULT($pac_cv_prog_f77_mismatched_args)
|
|
if test "$pac_cv_prog_f77_mismatched_args" = no ; then
|
|
AC_MSG_ERROR([The Fortran compiler $F77 will not compile files that call
|
|
the same routine with arguments of different types.])
|
|
fi
|
|
|
|
ifelse($1,,,[$1=$pac_cv_prog_f77_mismatched_args_parm])
|
|
])
|