OOPSE/ac-tools/aclocal.m4

dnl
dnl AC_CHECK_MODSUFFIX
dnl
AC_DEFUN([AC_CHECK_MODSUFFIX],[

AC_MSG_CHECKING(for module suffix)
rm -f conftest*
# Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
rm -f work*
cat >conftest.f <<EOF
        module conftest
        integer n
        parameter (n=1)
        end module conftest
EOF
# SGI and absoft compilers generates module name in upper case!
testname="conftest"
modcase="lower"
if $F90 -c conftest.f > conftest.out 2>&1 ; then
    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
    if test -z "$MOD" ; then
        MOD=`ls CONFTEST* 2>/dev/null \
                | grep -v CONFTEST.f | grep -v CONFTEST.o`
        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
        if test -n "$MOD" ; then
            testname="CONFTEST"
            modcase="upper"
        fi
    fi
    if test -z "$MOD" ; then
        AC_MSG_RESULT(unknown)
        # Use mod if we can't figure it out
        MOD="mod"
    else
        AC_MSG_RESULT($MOD)
    fi
    if test -s work.pcl ; then
        AC_MSG_WARN([Compiler generates auxillery files!])
    fi
else
    AC_MSG_RESULT(unknown)
fi
AC_SUBST(MOD)

])


dnl 
dnl AC_CHECK_MODDIRFLAG
dnl
AC_DEFUN([AC_CHECK_MODDIRFLAG],[

# Check for module include path (some use -I, some (Solaris) use -M, some
# (absoft) use -p).
# Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
# specified, work.pcl and work.pc are created.  However, if you specify
# a file, it must contain a the name of a file ending in .pc .  Ugh!
# Use the module made above
AC_MSG_CHECKING(for module directory path flag)
madedir=0
if test ! -d conf ; then mkdir conf ; madedir=1; fi
cp $testname.$MOD conf
rm -f conftest* CONFTEST*
cat >conftest1.f <<EOF
        program main
        use conftest
        print *, n
        end
EOF
F90_WORK_FILES_ARG=""
F90MODINCSPEC=""
if $F90 -c -Iconf conftest1.f > conftest.out 2>&1 ; then
    MODDIRFLAG="-I"
    F90MODINCSPEC="-I<dir>"
    AC_MSG_RESULT(-I)
elif $F90 -c -Mconf conftest1.f >> conftest.out 2>&1 ; then
    MODDIRFLAG="-M"
    F90MODINCSPEC="-M<dir>"
    AC_MSG_RESULT(-M)
elif $F90 -c -pconf conftest1.f >> conftest.out 2>&1 ; then
    MODDIRFLAG="-p"
    F90MODINCSPEC="-p<dir>"
    AC_MSG_RESULT(-p)
elif test -s work.pc ; then
     cp work.pc conf/mpimod.pc
     echo "mpimod.pc" > conf/mpimod.pcl
     echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
     if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
         MODDIRFLAG='-cl,mpimod.pcl'
         AC_MSG_RESULT([-cl,filename where filename contains a list of files and
 directories])
         F90_WORK_FILES_ARG="-cl,mpimod.pcl"
         F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
         AC_SUBST(F90_WORK_FILES_ARG)
     else
         # The version of the Intel compiler that I have refuses to let
         # you put the "work catalog" list anywhere but the current directory.
         # For example, you cannot in
         :
     fi
fi
if test -z "MODDIRFLAG" ; then
    AC_MSG_RESULT(unknown)
fi
AC_SUBST(MODDIRFLAG)
AC_SUBST(F90MODINCSPEC)
rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
if test $madedir = 1 ; then rmdir conf ; fi

])


dnl
dnl AC_CHECK_MPI_F90MOD
dnl
AC_DEFUN([AC_CHECK_MPI_F90MOD],[

  AC_ARG_WITH(mpi_f90_mods, [  --with-mpi_f90_mods=<dir>
                          Location where MPI f90 modules are installed ],
                           mpi_f90_mods="$withval", 
                           mpi_f90_mods="/usr/local/include/f90choice")

  AC_MSG_CHECKING(for MPI F90 modules)
  AC_LANG_SAVE()
  AC_LANG([Fortran 90])
  ac_save_F90FLAGS=$F90FLAGS

  AS_IF([test "$mpi_f90_mods"], [F90FLAGS="${F90FLAGS} ${MODDIRFLAG}${mpi_f90_mods}"])
    _AC_COMPILE_IFELSE([
    AC_LANG_PROGRAM([
use mpi
integer :: ierr
call MPI_Init(ierr)
])], [HAVE_MPI_MOD=1], [HAVE_MPI_MOD=0])
 
  F90FLAGS=$ac_save_F90FLAGS 
  AC_LANG_RESTORE()

  if test "$HAVE_MPI_MOD" = 1; then
    AC_MSG_RESULT(yes)
    AC_DEFINE(MPI_MOD, 1, [have mpi module])
    MPI_F90_MODS="${mpi_f90_mods}"
    AC_SUBST(MPI_F90_MODS)        
    # The library name:
    if test -z "$MPI_LIB" ; then 
       MPI_LIBNAME=-lmpich
    else 
       MPI_LIBNAME="$MPI_LIB" 
    fi
    if test -z "$MPIMODLIBNAME" ; then
       MPIMODLIBNAME="${MPI_LIBNAME}f90"
    fi
    AC_SUBST(MPIMODLIBNAME)
  else
    AC_MSG_RESULT(no)
    AC_MSG_ERROR([Couldn't locate MPI F90 Modules])
  fi

])


dnl
dnl AM_PATH_SPRNG
dnl
AC_DEFUN([AM_PATH_SPRNG],[

  AC_ARG_WITH(sprng_prefix, [  --with-sprng_prefix=PREFIX
                          Prefix where SPRNG is installed ],
                           sprng_prefix="$withval",
                           sprng_prefix="/usr/local")
  AC_ARG_WITH(sprng-libdir, [  --with-sprng-libdir=PREFIX  SPRNG library directory],
                           sprng_libdir="$withval",
                           sprng_libdir="/usr/local/lib")
  AC_ARG_WITH(sprng-include, [  --with-sprng-include=PREFIX
                          SPRNG include directory],
                           sprng_include="$withval",
                           sprng_include="/usr/local/include/sprng")

  if test x$sprng_libdir = x ; then
    sprng_libdir=${sprng_prefix}/lib
  fi

  if test x$sprng_include = x ; then
    sprng_include=${sprng_prefix}/include
  fi

  AC_MSG_CHECKING(for SPRNG include files in $sprng_include)
  if test -f ${sprng_include}/sprng.h; then
    have_sprngincl=yes
    AC_MSG_RESULT(yes)
  else
    have_sprngincl=no
    AC_MSG_RESULT(no)
    AC_MSG_ERROR(Could not locate the SPRNG include files)
  fi

  AC_MSG_CHECKING(for SPRNG libraries in $sprng_libdir)
  if test -f ${sprng_libdir}/libsprng.a; then
    have_sprnglib=yes
    AC_MSG_RESULT(yes)
  else
    have_sprnglib=no
    AC_MSG_RESULT(no)
    AC_MSG_ERROR(Could not locate the SPRNG libraries)
  fi

  AC_LANG_SAVE()
  AC_LANG([C])
  ac_save_CPPFLAGS=$CPPFLAGS
  CPPFLAGS="${CPPFLAGS} -I${sprng_include}"
  ac_save_LDFLAGS=$LDFLAGS
  LDFLAGS="${LDFLAGS} -L${sprng_libdir} -lsprng"
  AC_CHECK_HEADER(sprng.h, [
    AC_CHECK_LIB(sprng, 
                 init_rng, 
                    [SPRNG_LIBDIR="${sprng_libdir}"
                     SPRNG_LIB="-lsprng" SPRNG_INC="-I${sprng_include}"
                     HAVE_SPRNG="yes"])])
  CPPFLAGS=$ac_save_CPPFLAGS 
  LDFLAGS=$ac_save_LDFLAGS 
  AC_LANG_RESTORE()
  
  if test x_$HAVE_SPRNG != x_yes; then
        AC_MSG_ERROR(Can't build with SPRNG)
  fi
  AC_SUBST(SPRNG_LIBDIR)
  AC_SUBST(SPRNG_LIB)
  AC_SUBST(SPRNG_INC)
  AC_SUBST(HAVE_SPRNG)
])

dnl
dnl CHECK_MKL
dnl
AC_DEFUN([CHECK_MKL],
[AC_MSG_CHECKING(if MKL is wanted)
AC_ARG_WITH(mkl,
              [  --with-mkl              Do we want MKL [will check /usr/local/intel/mkl60 /opt/intel/mkl60]],
[   AC_MSG_RESULT(yes)
    for dir in $withval /usr/local/intel/mkl60 /opt/intel/mkl60; do
        mkldir="$dir"
        if test -f "$dir/include/mkl.h"; then
            found_mkl="yes";
            break;
        fi
    done
    if test x_$found_mkl != x_yes; then
        AC_MSG_ERROR(Cannot find MKL includes)
    else
        printf "MKL includes found in $mkldir/include\n";
    fi

  AC_LANG_SAVE()
  AC_LANG([C])
  ac_save_CPPFLAGS=$CPPFLAGS
  CPPFLAGS="${CPPFLAGS} -I${mkldir}/include"
  ac_save_LDFLAGS=$LDFLAGS
  LDFLAGS="${LDFLAGS} -L${mkldir}/lib/32 -lmkl -lvml -lguide"
  AC_CHECK_HEADER(mkl.h, [
    AC_CHECK_LIB(mkl, 
                 vslNewStream, 
                    [MKL_LIBDIR="${mkldir}/lib/32", 
                     MKL_LIB="-lmkl -lvml -lguide",
                     HAVE_MKL="yes"]) 
    ], [MKL_INC="-I${mkldir}/include"])
  CPPFLAGS=$ac_save_CPPFLAGS 
  LDFLAGS=$ac_save_LDFLAGS 
  AC_LANG_RESTORE()
  
  if test x_$HAVE_MKL != x_yes; then
        AC_MSG_ERROR(Can't build with MKL)
  fi
  AC_SUBST(MKL_LIBDIR)
  AC_SUBST(MKL_LIB)
  AC_SUBST(MKL_INC)
  AC_SUBST(HAVE_MKL)
],
[
    AC_MSG_RESULT(no)
])
])
dnl

AC_DEFUN(ACX_CHECK_CC_FLAGS,
[
AC_REQUIRE([AC_PROG_CC])
AC_CACHE_CHECK(whether ${CC-cc} accepts $1, ac_$2,
[echo 'void f(){}' > conftest.c
if test -z "`${CC-cc} $1 -c conftest.c 2>&1`"; then
        ac_$2=yes
else
        ac_$2=no
fi
rm -f conftest*
])
if test "$ac_$2" = yes; then
        :
        $3
else
        :
        $4
fi
])

AC_DEFUN(ACX_CHECK_CXX_FLAGS,
[
AC_REQUIRE([AC_PROG_CXX])
AC_CACHE_CHECK(whether ${CXX-c++} accepts $1, ac_$2,
[echo 'void f(){}' > conftest.cpp
if test -z "`${CXX-c++} $1 -c conftest.cpp 2>&1`"; then
        ac_$2=yes
else
        ac_$2=no
fi
rm -f conftest*
])
if test "$ac_$2" = yes; then
        :
        $3
else
        :
        $4
fi
])

dnl -------------------------------------------------------------------------
dnl ACX_CHECK_F90_FLAGS()
dnl
dnl     Check for optimizer flags the Fortran compiler can use.
dnl
AC_DEFUN(ACX_CHECK_F90_FLAGS,
[
AC_CACHE_CHECK(whether ${F90-f90} accepts $1, ac_$2,
[
AC_LANG_SAVE
AC_LANG([Fortran 90])
echo 'program main' > conftest.$ac_ext
echo 'end program main' >> conftest.$ac_ext
ac_compile='${F90-f90} -c $1 $F90FLAGS conftest.$ac_ext 1>&AC_FD_CC'
if AC_TRY_EVAL(ac_compile); then
        ac_$2=yes
else
        ac_$2=no
fi
rm -f conftest*
AC_LANG_RESTORE()
])
if test "$ac_$2" = yes; then
        :
        $3
else
        :
        $4
fi
])
 
AC_DEFUN(ACX_PROG_GCC_VERSION,
[
AC_REQUIRE([AC_PROG_CC])
AC_CACHE_CHECK(whether we are using gcc $1.$2 or later, ac_cv_prog_gcc_$1_$2,
[
dnl The semicolon after "yes" below is to pacify NeXT's syntax-checking cpp.
cat > conftest.c <<EOF
#ifdef __GNUC__
#  if (__GNUC__ > $1) || (__GNUC__ == $1 && __GNUC_MINOR__ >= $2)
     yes;
#  endif
#endif
EOF
if AC_TRY_COMMAND(${CC-cc} -E conftest.c) | egrep yes >/dev/null 2>&1; then
  ac_cv_prog_gcc_$1_$2=yes
else
  ac_cv_prog_gcc_$1_$2=no
fi
])
if test "$ac_cv_prog_gcc_$1_$2" = yes; then
        :
        $3
else
        :
        $4
fi
])


AC_DEFUN(ACX_PROG_CC_MAXOPT,
[
AC_REQUIRE([AC_PROG_CC])
AC_REQUIRE([AC_CANONICAL_HOST])

# Try to determine "good" native compiler flags if none specified on command
# line
if test "$ac_test_CFLAGS" != "set"; then
  CFLAGS=""
  case "${host_cpu}-${host_os}" in

  *linux*) if test "$CC" = icc; then
                    CFLAGS="-O"
                fi;;
  sparc-solaris2*) if test "$CC" = cc; then
                    CFLAGS="-native -fast -xO5 -dalign"
                 fi;;

  alpha*-osf*)  if test "$CC" = cc; then
                    CFLAGS="-newc -w0 -O5 -ansi_alias -ansi_args -fp_reorder -tune host -arch host -std1"
                fi;;

  hppa*-hpux*)  if test "$CC" = cc; then
                    CFLAGS="-Ae +O3 +Oall"
                fi;;

   rs6000*-aix*)  if test "$CC" = cc -o "$CC" = xlc; then
                    CFLAGS="-O3 -qtune=auto -qansialias -w"
                fi;;
   powerpc*-aix*)
        if test "$CC" = cc -o "$CC" = xlc; then
                CFLAGS="-O3 -qtune=auto -qansialias -w"
                echo "*******************************************************"
                echo "*  You have AIX on an unknown powerpc system.  It is  *"
                echo "*  recommended that you use                           *"
                echo "*                                                     *"
                echo "*    CFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
                echo "*                                 ^^^                 *"
                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
                echo "*******************************************************"
        fi;;
   *darwin*)
        if test "$CC" = xlc -o "$CC" = cc; then
                CFLAGS="-O3 -qtune=auto -w"
                echo "*******************************************************"
                echo "*  You have Darwin on an unknown powerpc system.      *"
                echo "*  It is recommended that you use                     *"
                echo "*                                                     *"
                echo "*  CFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w    *"
                echo "*                               ^^^                   *"
                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
                echo "*******************************************************"
        fi;;
  esac

  # use default flags for gcc on all systems
  if test $ac_cv_prog_gcc = yes; then
     CFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
  fi

  # test for gcc-specific flags:
  if test $ac_cv_prog_gcc = yes; then
    # -malign-double for x86 systems
    ACX_CHECK_CC_FLAGS(-malign-double,align_double, CFLAGS="$CFLAGS -malign-double")
    # -fstrict-aliasing for gcc-2.95+
    ACX_CHECK_CC_FLAGS(-fstrict-aliasing,fstrict_aliasing, CFLAGS="$CFLAGS -fstrict-aliasing")
  fi

  CPU_FLAGS=""
  if test "$GCC" = "yes"; then
          dnl try to guess correct CPU flags, at least for linux
          case "${host_cpu}" in
          i586*)  ACX_CHECK_CC_FLAGS(-mcpu=pentium,cpu_pentium,
                        [CPU_FLAGS=-mcpu=pentium],
                        [ACX_CHECK_CC_FLAGS(-mpentium,pentium,
                                [CPU_FLAGS=-mpentium])])
                  ;;
          i686*)  ACX_CHECK_CC_FLAGS(-mcpu=pentiumpro,cpu_pentiumpro,
                        [CPU_FLAGS=-mcpu=pentiumpro],
                        [ACX_CHECK_CC_FLAGS(-mpentiumpro,pentiumpro,
                                [CPU_FLAGS=-mpentiumpro])])
                  ;;
          powerpc*)
                cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
                is60x=`echo $cputype | egrep "^60[0-9]e?$"`
                if test -n "$is60x"; then
                        ACX_CHECK_CC_FLAGS(-mcpu=$cputype,m_cpu_60x,
                                CPU_FLAGS=-mcpu=$cputype)
                elif test "$cputype" = 750; then
                        ACX_PROG_GCC_VERSION(2,95,
                                ACX_CHECK_CC_FLAGS(-mcpu=750,m_cpu_750,
                                        CPU_FLAGS=-mcpu=750))
                fi
                if test -z "$CPU_FLAGS"; then
                        ACX_CHECK_CC_FLAGS(-mcpu=powerpc,m_cpu_powerpc,
                                CPU_FLAGS=-mcpu=powerpc)
                fi
                if test -z "$CPU_FLAGS"; then
                        ACX_CHECK_CC_FLAGS(-mpowerpc,m_powerpc,
                                CPU_FLAGS=-mpowerpc)
                fi
          esac
  fi

  if test -n "$CPU_FLAGS"; then
        CFLAGS="$CFLAGS $CPU_FLAGS"
  fi

  if test -z "$CFLAGS"; then
        echo ""
        echo "********************************************************"
        echo "* WARNING: Don't know the best CFLAGS for this system  *"
        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
        echo "* (otherwise, a default of CFLAGS=-O3 will be used)    *"
        echo "********************************************************"
        echo ""
        CFLAGS="-O3"
  fi

  ACX_CHECK_CC_FLAGS(${CFLAGS}, guessed_cflags, , [
        echo ""
        echo "********************************************************"
        echo "* WARNING: The guessed CFLAGS don't seem to work with  *"
        echo "* your compiler.                                       *"
        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
        echo "********************************************************"
        echo ""
        CFLAGS=""
  ])

fi
])

AC_DEFUN(ACX_PROG_CXX_MAXOPT,
[
AC_REQUIRE([AC_PROG_CXX])
AC_REQUIRE([AC_CANONICAL_HOST])

# Try to determine "good" native compiler flags if none specified on command
# line
if test "$ac_test_CXXFLAGS" != "set"; then
  CXXFLAGS=""
  case "${host_cpu}-${host_os}" in

  *linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
                    CXXFLAGS="-O"
                fi;;
  sparc-solaris2*) if test "$CXX" = CC; then
                    CXXFLAGS="-native -fast -xO5 -dalign"
                 fi;;
   rs6000*-aix*)  if test "$CXX" = xlC; then
                    CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
                fi;;
   powerpc*-aix*)
        if test "$CXX" = xlC; then
                CXXFLAGS="-O3 -qarch=ppc -qansialias -w"
                echo "*******************************************************"
                echo "*  You have AIX on an unknown powerpc system.  It is  *"
                echo "*  recommended that you use                           *"
                echo "*                                                     *"
                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
                echo "*                                 ^^^                 *"
                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
                echo "*******************************************************"
        fi;;
   *darwin*)
        if test "$CXX" = xlC; then
                CXXFLAGS="-O3 -qtune=auto -qansialias -w"
                echo "*******************************************************"
                echo "*  You have AIX on an unknown powerpc system.  It is  *"
                echo "*  recommended that you use                           *"
                echo "*                                                     *"
                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
                echo "*                                 ^^^                 *"
                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
                echo "*******************************************************"
        fi;;
  esac

  # use default flags for gcc on all systems
  if test $ac_cv_prog_gcc = yes; then
     CXXFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
  fi

  # test for gcc-specific flags:
  if test $ac_cv_prog_gcc = yes; then
    # -malign-double for x86 systems
    ACX_CHECK_CXX_FLAGS(-malign-double,align_double, CXXFLAGS="$CXXFLAGS -malign-double")
    # -fstrict-aliasing for gcc-2.95+
    ACX_CHECK_CXX_FLAGS(-fstrict-aliasing,fstrict_aliasing, CXXFLAGS="$CXXFLAGS -fstrict-aliasing")
  fi

  CPU_FLAGS=""
  if test "$GCC" = "yes"; then
          dnl try to guess correct CPU flags, at least for linux
          case "${host_cpu}" in
          i586*)  ACX_CHECK_CC_FLAGS(-mcpu=pentium,cpu_pentium,
                        [CPU_FLAGS=-mcpu=pentium],
                        [ACX_CHECK_CXX_FLAGS(-mpentium,pentium,
                                [CPU_FLAGS=-mpentium])])
                  ;;
          i686*)  ACX_CHECK_CXX_FLAGS(-mcpu=pentiumpro,cpu_pentiumpro,
                        [CPU_FLAGS=-mcpu=pentiumpro],
                        [ACX_CHECK_CXX_FLAGS(-mpentiumpro,pentiumpro,
                                [CPU_FLAGS=-mpentiumpro])])
                  ;;
          powerpc*)
                cputype=`(grep cpu /proc/cpuinfo | head -1 | cut -d: -f2 | sed 's/ //g') 2> /dev/null`
                is60x=`echo $cputype | egrep "^60[0-9]e?$"`
                if test -n "$is60x"; then
                        ACX_CHECK_CXX_FLAGS(-mcpu=$cputype,m_cpu_60x,
                                CPU_FLAGS=-mcpu=$cputype)
                elif test "$cputype" = 750; then
                        ACX_PROG_GCC_VERSION(2,95,
                                ACX_CHECK_CXX_FLAGS(-mcpu=750,m_cpu_750,
                                        CPU_FLAGS=-mcpu=750))
                fi
                if test -z "$CPU_FLAGS"; then
                        ACX_CHECK_CXX_FLAGS(-mcpu=powerpc,m_cpu_powerpc,
                                CPU_FLAGS=-mcpu=powerpc)
                fi
                if test -z "$CPU_FLAGS"; then
                        ACX_CHECK_CXX_FLAGS(-mpowerpc,m_powerpc,
                                CPU_FLAGS=-mpowerpc)
                fi
          esac
  fi

  if test -n "$CPU_FLAGS"; then
        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
  fi

  if test -z "$CXXFLAGS"; then
        echo ""
        echo "**********************************************************"
        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
        echo "**********************************************************"
        echo ""
        CXXFLAGS="-O3"
  fi

  ACX_CHECK_CXX_FLAGS(${CXXFLAGS}, guessed_cxxflags, , [
        echo ""
        echo "**********************************************************"
        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
        echo "* your compiler.                                         *"
        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
        echo "**********************************************************"
        echo ""
        CXXFLAGS=""
  ])

fi
])

AC_DEFUN(ACX_PROG_F90_MAXOPT,
[
AC_REQUIRE([AC_PROG_F90])
AC_REQUIRE([AC_CANONICAL_HOST])

# Try to determine "good" native compiler flags if none specified on command
# line

if test x"$F90FLAGS" = x ; then
  F90FLAGS=""
  case "${host_cpu}-${host_os}" in

  *linux*) if test "$F90" = ifc; then
                    F90FLAGS="-O"
                fi;;
   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
                fi;;
   powerpc*-aix*)
        if test "$F90" = f90 -o "$F90" = xlf90; then
                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
                echo "*******************************************************"
                echo "*  You have AIX on an unknown powerpc system.  It is  *"
                echo "*  recommended that you use                           *"
                echo "*                                                     *"
                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
                echo "*                                 ^^^                 *"
                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
                echo "*******************************************************"
        fi;;
   *darwin*)
        if test "$F90" = f90 -o "$F90" = xlf90; then
                F90FLAGS="-O3 -qtune=auto -w"
                echo "*********************************************************"
                echo "*  You have Darwin on an unknown powerpc system.  It is *"
                echo "*  recommended that you use                             *"
                echo "*                                                       *"
                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w    *"
                echo "*                                 ^^^                   *"
                echo "*  where xxx is 601, 603, 604, or whatever kind of      *"
                echo "*  PowerPC CPU you have.   For more info, man xlf.      *"
                echo "*********************************************************"
        fi;;
  esac

  if test -n "$CPU_FLAGS"; then
        F90FLAGS="$F90FLAGS $CPU_FLAGS"
  fi

  if test -z "$F90FLAGS"; then
        echo ""
        echo "**********************************************************"
        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
        echo "**********************************************************"
        echo ""
        F90FLAGS="-O3"
  fi

  ACX_CHECK_F90_FLAGS(${F90FLAGS}, guessed_f90flags, , [
        echo ""
        echo "**********************************************************"
        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
        echo "* your compiler.                                         *"
        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
        echo "**********************************************************"
        echo ""
        F90FLAGS=""
  ])

fi
])

AC_DEFUN(ACX_PROG_F90_PREPFLAG,
[
AC_REQUIRE([AC_PROG_F90])
AC_REQUIRE([AC_CANONICAL_HOST])

# Try to determine native compiler flags that allow us to use F90 suffix
# for preprocessed f90 source. 

if test "$ac_test_PREPFLAG" != "set"; then
  PREPFLAG=""
  case "${host_cpu}-${host_os}" in

  *linux*) if test "$F90" = ifc; then
                    PREPFLAG="-fpp1 "
                fi;;
  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
                    PREPFLAG="-qsuffix=cpp=F90 "
                fi;;
  *darwin*)
        if test "$F90" = f90 -o "$F90" = xlf90; then
                PREPFLAG="-qsuffix=cpp=F90 "
        fi;;
  esac

  if test -z "$PREPFLAG"; then
        echo ""
        echo "**********************************************************"
        echo "* WARNING: Don't know the best PREPFLAG for this system  *"
        echo "* Use  make PREPFLAG=..., or edit the top level Makefile *"
        echo "* (otherwise, an empty PREPFLAG will be used)            *"
        echo "**********************************************************"
        echo ""
        PREPFLAG=""
  fi

  AC_MSG_CHECKING(to make sure F90 preprocessor flag works)
  AC_LANG_SAVE()
  AC_LANG([Fortran 90])
  ac_save_ext=$ac_ext
  ac_ext=F90
  ac_save_F90FLAGS=$F90FLAGS

  AS_IF([test "$PREPFLAG"], [F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"])
    _AC_COMPILE_IFELSE([
      AC_LANG_PROGRAM([
  integer :: i
  i = 1
])], [prepflagworks=1], [prepflagworks=0])

  F90FLAGS=$ac_save_F90FLAGS 
  ac_ext=$ac_save_ext
  AC_LANG_RESTORE()


  if test "$prepflagworks" = 1; then
    AC_MSG_RESULT(yes)
    AC_SUBST(PREPFLAG)
  else
    AC_MSG_RESULT(no)
    AC_MSG_ERROR([Can't figure out working Fortran90 preprocessor flag])
  fi
fi
])


AC_DEFUN(ACX_PROG_F90_PREPDEFFLAG,
[
AC_REQUIRE([AC_PROG_F90])
AC_REQUIRE([AC_CANONICAL_HOST])

# Try to determine native compiler flags that allow us to use F90 suffix
# for preprocessed f90 source with -D type defines

if test "$ac_test_PREPDEFFLAG" != "set"; then
  PREPDEFFLAG=""
  case "${host_cpu}-${host_os}" in

  *linux*) if test "$F90" = ifc; then
                    PREPDEFFLAG=" "
                fi;;
  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
                    PREPDEFFLAG="-WF,"
                fi;;
  *darwin*)
        if test "$F90" = f90 -o "$F90" = xlf90; then
                PREPDEFFLAG="-WF,"
        fi;;
  esac

  if test -z "$PREPDEFFLAG"; then
        echo ""
        echo "*************************************************************"
        echo "* WARNING: Don't know the best PREPDEFFLAG for this system  *"
        echo "* Use  make PREPDEFFLAG=..., or edit the top level Makefile *"
        echo "* (otherwise, an empty PREPDEFFLAG will be used)            *"
        echo "*************************************************************"
        echo ""
        PREPDEFFLAG=" "
  fi

  AC_MSG_CHECKING(to make sure F90 preprocessor define flag works)
  AC_LANG_SAVE()
  AC_LANG([Fortran 90])
  ac_save_ext=$ac_ext
  ac_ext=F90
  ac_save_F90FLAGS=$F90FLAGS

  AS_IF([test "$PREPDEFFLAG"], [F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"])
    _AC_COMPILE_IFELSE([
      AC_LANG_PROGRAM([
  integer :: i
#ifdef TEST
  i = 1
#else
  choke me
#endif
])], [prepdefflagworks=1], [prepdefflagworks=0])

  F90FLAGS=$ac_save_F90FLAGS 
  ac_ext=$ac_save_ext
  AC_LANG_RESTORE()


  if test "$prepdefflagworks" = 1; then
    AC_MSG_RESULT(yes)
    AC_SUBST(PREPDEFFLAG)
  else
    AC_MSG_RESULT(no)
    AC_MSG_ERROR([Can't figure out working Fortran90 preprocessor define flag])
  fi
fi
])

AC_DEFUN([ACX_MPI], [
AC_PREREQ(2.50) dnl for AC_LANG_CASE

AC_LANG_CASE([C], [
        AC_REQUIRE([AC_PROG_CC])
        AC_ARG_VAR(MPICC,[MPI C compiler command])
        AC_CHECK_PROGS(MPICC, mpicc hcc mpcc mpcc_r mpxlc, $CC)
        acx_mpi_save_CC="$CC"
        CC="$MPICC"
        AC_SUBST(MPICC)
],
[C++], [
        AC_REQUIRE([AC_PROG_CXX])
        AC_ARG_VAR(MPICXX,[MPI C++ compiler command])
        AC_CHECK_PROGS(MPICXX, mpiCC mpCC, $CXX)
        acx_mpi_save_CXX="$CXX"
        CXX="$MPICXX"
        AC_SUBST(MPICXX)
],
[Fortran 90], [
        AC_REQUIRE([AC_PROG_F90])
        AC_ARG_VAR(MPIF77,[MPI Fortran compiler command])
        AC_CHECK_PROGS(MPIF90, mpif90 hf90 mpxlf90 mpf90 mpxlf95 mpxlf_r, $F90)
        acx_mpi_save_F90="$F90"
        F90="$MPIF90"
        AC_SUBST(MPIF90)
])

if test x = x"$MPILIBS"; then
        AC_LANG_CASE([C], [AC_CHECK_FUNC(MPI_Init, [MPILIBS=" "])],
                [C++], [AC_CHECK_FUNC(MPI_Init, [MPILIBS=" "])],
                [Fortran 90], [AC_MSG_CHECKING([for MPI_Init])
                        AC_TRY_LINK([],[      call MPI_Init], [MPILIBS=" "
                                AC_MSG_RESULT(yes)], [AC_MSG_RESULT(no)])])
fi
if test x = x"$MPILIBS"; then
        AC_CHECK_LIB(mpi, MPI_Init, [MPILIBS="-lmpi"])
fi
if test x = x"$MPILIBS"; then
        AC_CHECK_LIB(mpich, MPI_Init, [MPILIBS="-lmpich"])
fi

dnl We have to use AC_TRY_COMPILE and not AC_CHECK_HEADER because the
dnl latter uses $CPP, not $CC (which may be mpicc).
AC_LANG_CASE([C], [if test x != x"$MPILIBS"; then
        AC_MSG_CHECKING([for mpi.h])
        AC_TRY_COMPILE([#include <mpi.h>],[],[AC_MSG_RESULT(yes)], [MPILIBS=""
                AC_MSG_RESULT(no)])
fi],
[C++], [if test x != x"$MPILIBS"; then
        AC_MSG_CHECKING([for mpi.h])
        AC_TRY_COMPILE([#include <mpi.h>],[],[AC_MSG_RESULT(yes)], [MPILIBS=""
                AC_MSG_RESULT(no)])
fi])

AC_LANG_CASE([C], [CC="$acx_mpi_save_CC"],
        [C++], [CXX="$acx_mpi_save_CXX"],
        [Fortran 90], [F90="$acx_mpi_save_F90"])

AC_SUBST(MPILIBS)

# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
if test x = x"$MPILIBS"; then
        $2
        :
else
        ifelse([$1],,[AC_DEFINE(HAVE_MPI,1,[Define if you have the MPI library.])],[$1])
        :
fi
])dnl ACX_MPI

Revision:	827
Committed:	Tue Oct 28 16:02:29 2003 UTC (22 years, 1 month ago) by gezelter
File size:	28194 byte(s)
Log Message:	mod file fixes and portability stuff