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