ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/configure
(Generate patch)

Comparing trunk/configure (file contents):
Revision 340 by gezelter, Tue Feb 15 05:05:33 2005 UTC vs.
Revision 956 by gezelter, Tue May 16 02:06:37 2006 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.57 for OOPSE 2.0.
3 > # Generated by GNU Autoconf 2.59 for OOPSE 3.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
7 < # Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
8 < # Free Software Foundation, Inc.
7 > # Copyright (C) 2003 Free Software Foundation, Inc.
8   # This configure script is free software; the Free Software Foundation
9   # gives unlimited permission to copy, distribute and modify it.
10   ## --------------------- ##
# Line 22 | Line 21 | fi
21   elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
22    set -o posix
23   fi
24 + DUALCASE=1; export DUALCASE # for MKS sh
25  
26   # Support unset when possible.
27 < if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
27 > if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
28    as_unset=unset
29   else
30    as_unset=false
# Line 43 | Line 43 | do
43    LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
44    LC_TELEPHONE LC_TIME
45   do
46 <  if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then
46 >  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
47      eval $as_var=C; export $as_var
48    else
49      $as_unset $as_var
# Line 220 | Line 220 | else
220   if mkdir -p . 2>/dev/null; then
221    as_mkdir_p=:
222   else
223 +  test -d ./-p && rmdir ./-p
224    as_mkdir_p=false
225   fi
226  
227   as_executable_p="test -f"
228  
229   # Sed expression to map a string onto a valid CPP name.
230 < as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
230 > as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
231  
232   # Sed expression to map a string onto a valid variable name.
233 < as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
233 > as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
234  
235  
236   # IFS
# Line 268 | Line 269 | PACKAGE_TARNAME='oopse'
269   # Identity of this package.
270   PACKAGE_NAME='OOPSE'
271   PACKAGE_TARNAME='oopse'
272 < PACKAGE_VERSION='2.0'
273 < PACKAGE_STRING='OOPSE 2.0'
272 > PACKAGE_VERSION='3.0'
273 > PACKAGE_STRING='OOPSE 3.0'
274   PACKAGE_BUGREPORT='gezelter@nd.edu'
275  
276   ac_unique_file="src/applications/oopse/oopse.cpp"
# Line 311 | Line 312 | ac_includes_default="\
312   # include <unistd.h>
313   #endif"
314  
315 < ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX OOPSE_TEMPLATE_FLAGS EXTRA_CC_FLAG F90 F90FLAGS ac_ct_F90 PREPFLAG PREPDEFFLAG F90LIBS F90_FUNC F90_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES CPP EGREP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT AR PS MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI SPRNG_LIB_DIR SPRNG_INC_DIR SPRNG_LIB USE_SPRNG MKL_LIBDIR MKL_LIB MKL_INC HAVE_MKL DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 670 | Line 671 | for ac_var in bindir sbindir libexecdir datadir syscon
671  
672   # Be sure to have absolute paths.
673   for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
674 <              localstatedir libdir includedir oldincludedir infodir mandir
674 >              localstatedir libdir includedir oldincludedir infodir mandir
675   do
676    eval ac_val=$`echo $ac_var`
677    case $ac_val in
# Line 710 | Line 711 | $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
711    # Try the directory containing this script, then its parent.
712    ac_confdir=`(dirname "$0") 2>/dev/null ||
713   $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
714 <         X"$0" : 'X\(//\)[^/]' \| \
715 <         X"$0" : 'X\(//\)$' \| \
716 <         X"$0" : 'X\(/\)' \| \
717 <         .     : '\(.\)' 2>/dev/null ||
714 >         X"$0" : 'X\(//\)[^/]' \| \
715 >         X"$0" : 'X\(//\)$' \| \
716 >         X"$0" : 'X\(/\)' \| \
717 >         .     : '\(.\)' 2>/dev/null ||
718   echo X"$0" |
719      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
720            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 752 | Line 753 | ac_cv_env_target_alias_value=$target_alias
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 < ac_env_CC_set=${CC+set}
757 < ac_env_CC_value=$CC
758 < ac_cv_env_CC_set=${CC+set}
759 < ac_cv_env_CC_value=$CC
760 < ac_env_CFLAGS_set=${CFLAGS+set}
761 < ac_env_CFLAGS_value=$CFLAGS
762 < ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 < ac_cv_env_CFLAGS_value=$CFLAGS
756 > ac_env_CXX_set=${CXX+set}
757 > ac_env_CXX_value=$CXX
758 > ac_cv_env_CXX_set=${CXX+set}
759 > ac_cv_env_CXX_value=$CXX
760 > ac_env_CXXFLAGS_set=${CXXFLAGS+set}
761 > ac_env_CXXFLAGS_value=$CXXFLAGS
762 > ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763 > ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764   ac_env_LDFLAGS_set=${LDFLAGS+set}
765   ac_env_LDFLAGS_value=$LDFLAGS
766   ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
# Line 768 | Line 769 | ac_cv_env_CPPFLAGS_value=$CPPFLAGS
769   ac_env_CPPFLAGS_value=$CPPFLAGS
770   ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771   ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772 < ac_env_CXX_set=${CXX+set}
773 < ac_env_CXX_value=$CXX
774 < ac_cv_env_CXX_set=${CXX+set}
775 < ac_cv_env_CXX_value=$CXX
776 < ac_env_CXXFLAGS_set=${CXXFLAGS+set}
777 < ac_env_CXXFLAGS_value=$CXXFLAGS
778 < ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
779 < ac_cv_env_CXXFLAGS_value=$CXXFLAGS
780 < ac_env_F90_set=${F90+set}
781 < ac_env_F90_value=$F90
782 < ac_cv_env_F90_set=${F90+set}
783 < ac_cv_env_F90_value=$F90
784 < ac_env_F90FLAGS_set=${F90FLAGS+set}
785 < ac_env_F90FLAGS_value=$F90FLAGS
786 < ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
787 < ac_cv_env_F90FLAGS_value=$F90FLAGS
772 > ac_env_CC_set=${CC+set}
773 > ac_env_CC_value=$CC
774 > ac_cv_env_CC_set=${CC+set}
775 > ac_cv_env_CC_value=$CC
776 > ac_env_CFLAGS_set=${CFLAGS+set}
777 > ac_env_CFLAGS_value=$CFLAGS
778 > ac_cv_env_CFLAGS_set=${CFLAGS+set}
779 > ac_cv_env_CFLAGS_value=$CFLAGS
780 > ac_env_FC_set=${FC+set}
781 > ac_env_FC_value=$FC
782 > ac_cv_env_FC_set=${FC+set}
783 > ac_cv_env_FC_value=$FC
784 > ac_env_FCFLAGS_set=${FCFLAGS+set}
785 > ac_env_FCFLAGS_value=$FCFLAGS
786 > ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787 > ac_cv_env_FCFLAGS_value=$FCFLAGS
788   ac_env_CPP_set=${CPP+set}
789   ac_env_CPP_value=$CPP
790   ac_cv_env_CPP_set=${CPP+set}
791   ac_cv_env_CPP_value=$CPP
792 + ac_env_CXXCPP_set=${CXXCPP+set}
793 + ac_env_CXXCPP_value=$CXXCPP
794 + ac_cv_env_CXXCPP_set=${CXXCPP+set}
795 + ac_cv_env_CXXCPP_value=$CXXCPP
796  
797   #
798   # Report the --help message.
# Line 796 | Line 801 | if test "$ac_init_help" = "long"; then
801    # Omit some internal or obsolete options to make the list less imposing.
802    # This message is too long to be a string in the A/UX 3.1 sh.
803    cat <<_ACEOF
804 < \`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804 > \`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
805  
806   Usage: $0 [OPTION]... [VAR=VALUE]...
807  
# Line 821 | Line 826 | Installation directories:
826    cat <<_ACEOF
827   Installation directories:
828    --prefix=PREFIX         install architecture-independent files in PREFIX
829 <                          [$ac_default_prefix]
829 >                          [$ac_default_prefix]
830    --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
831 <                          [PREFIX]
831 >                          [PREFIX]
832  
833   By default, \`make install' will install all the files in
834   \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
# Line 857 | Line 862 | if test -n "$ac_init_help"; then
862  
863   if test -n "$ac_init_help"; then
864    case $ac_init_help in
865 <     short | recursive ) echo "Configuration of OOPSE 2.0:";;
865 >     short | recursive ) echo "Configuration of OOPSE 3.0:";;
866     esac
867    cat <<\_ACEOF
868  
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872 +  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873    --enable-debug          Compile OOPSE in debug mode
874    --enable-doxygen        enable documentation generation with doxygen (auto)
875    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
876    --enable-html-docs      enable HTML generation with doxygen (yes)
877    --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
872  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
878  
879   Optional Packages:
880    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
881    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882 +  --with-perl-shebang     override what perl thinks is the way for the kernel
883 +                          to start it (seldom needed)
884 +  --with-zlib=DIR root directory path of zlib installation defaults to
885 +                    /usr/local or /usr if not found in /usr/local
886 +  --without-zlib to disable zlib usage completely
887 +  --without-fftw          if you turn this off you cannot compute undulation spectra
888    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
889 <  --with-sprng=<prefix>   compile with SPRNG installed in <prefix>
879 <                          [default=/usr/local]
880 <  --with-mkl              Do we want MKL will check /usr/local/intel/mkl61 /opt/intel/mkl61
889 >  --with-cgal-makefile=FILE  CGAL makefile that should be used
890  
891   Some influential environment variables:
892 <  CC          C compiler command
893 <  CFLAGS      C compiler flags
892 >  CXX         C++ compiler command
893 >  CXXFLAGS    C++ compiler flags
894    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
895                nonstandard directory <lib dir>
896    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
897                headers in a nonstandard directory <include dir>
898 <  CXX         C++ compiler command
899 <  CXXFLAGS    C++ compiler flags
900 <  F90         Fortran 90 compiler command
901 <  F90FLAGS    Fortran 90 compiler flags
898 >  CC          C compiler command
899 >  CFLAGS      C compiler flags
900 >  FC          Fortran compiler command
901 >  FCFLAGS     Fortran compiler flags
902    CPP         C preprocessor
903 +  CXXCPP      C++ preprocessor
904  
905   Use these variables to override the choices made by `configure' or to help
906   it to find libraries and programs with nonstandard names/locations.
# Line 929 | Line 939 | esac
939      ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
940      ac_top_srcdir=$ac_top_builddir$srcdir ;;
941   esac
942 < # Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be
943 < # absolute.
944 < ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`
945 < ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd`
946 < ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`
947 < ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`
942 >
943 > # Do not use `cd foo && pwd` to compute absolute paths, because
944 > # the directories may not exist.
945 > case `pwd` in
946 > .) ac_abs_builddir="$ac_dir";;
947 > *)
948 >  case "$ac_dir" in
949 >  .) ac_abs_builddir=`pwd`;;
950 >  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
951 >  *) ac_abs_builddir=`pwd`/"$ac_dir";;
952 >  esac;;
953 > esac
954 > case $ac_abs_builddir in
955 > .) ac_abs_top_builddir=${ac_top_builddir}.;;
956 > *)
957 >  case ${ac_top_builddir}. in
958 >  .) ac_abs_top_builddir=$ac_abs_builddir;;
959 >  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
960 >  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
961 >  esac;;
962 > esac
963 > case $ac_abs_builddir in
964 > .) ac_abs_srcdir=$ac_srcdir;;
965 > *)
966 >  case $ac_srcdir in
967 >  .) ac_abs_srcdir=$ac_abs_builddir;;
968 >  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
969 >  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
970 >  esac;;
971 > esac
972 > case $ac_abs_builddir in
973 > .) ac_abs_top_srcdir=$ac_top_srcdir;;
974 > *)
975 >  case $ac_top_srcdir in
976 >  .) ac_abs_top_srcdir=$ac_abs_builddir;;
977 >  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
978 >  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
979 >  esac;;
980 > esac
981  
982      cd $ac_dir
983      # Check for guested configure; otherwise get Cygnus style configure.
# Line 945 | Line 988 | ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir &
988        echo
989        $SHELL $ac_srcdir/configure  --help=recursive
990      elif test -f $ac_srcdir/configure.ac ||
991 <           test -f $ac_srcdir/configure.in; then
991 >           test -f $ac_srcdir/configure.in; then
992        echo
993        $ac_configure --help
994      else
# Line 958 | Line 1001 | if $ac_init_version; then
1001   test -n "$ac_init_help" && exit 0
1002   if $ac_init_version; then
1003    cat <<\_ACEOF
1004 < OOPSE configure 2.0
1005 < generated by GNU Autoconf 2.57
1004 > OOPSE configure 3.0
1005 > generated by GNU Autoconf 2.59
1006  
1007 < Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
965 < Free Software Foundation, Inc.
1007 > Copyright (C) 2003 Free Software Foundation, Inc.
1008   This configure script is free software; the Free Software Foundation
1009   gives unlimited permission to copy, distribute and modify it.
1010   _ACEOF
# Line 973 | Line 1015 | running configure, to aid debugging if configure makes
1015   This file contains any messages produced by compilers while
1016   running configure, to aid debugging if configure makes a mistake.
1017  
1018 < It was created by OOPSE $as_me 2.0, which was
1019 < generated by GNU Autoconf 2.57.  Invocation command line was
1018 > It was created by OOPSE $as_me 3.0, which was
1019 > generated by GNU Autoconf 2.59.  Invocation command line was
1020  
1021    $ $0 $@
1022  
# Line 1051 | Line 1093 | do
1093      2)
1094        ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1095        if test $ac_must_keep_next = true; then
1096 <        ac_must_keep_next=false # Got value, back to normal.
1096 >        ac_must_keep_next=false # Got value, back to normal.
1097        else
1098 <        case $ac_arg in
1099 <          *=* | --config-cache | -C | -disable-* | --disable-* \
1100 <          | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1101 <          | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1102 <          | -with-* | --with-* | -without-* | --without-* | --x)
1103 <            case "$ac_configure_args0 " in
1104 <              "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1105 <            esac
1106 <            ;;
1107 <          -* ) ac_must_keep_next=true ;;
1108 <        esac
1098 >        case $ac_arg in
1099 >          *=* | --config-cache | -C | -disable-* | --disable-* \
1100 >          | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1101 >          | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1102 >          | -with-* | --with-* | -without-* | --without-* | --x)
1103 >            case "$ac_configure_args0 " in
1104 >              "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1105 >            esac
1106 >            ;;
1107 >          -* ) ac_must_keep_next=true ;;
1108 >        esac
1109        fi
1110        ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1111        # Get rid of the leading space.
# Line 1097 | Line 1139 | _ASBOX
1139      case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1140      *ac_space=\ *)
1141        sed -n \
1142 <        "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1143 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1142 >        "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1143 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1144        ;;
1145      *)
1146        sed -n \
1147 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1147 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1148        ;;
1149      esac;
1150   }
# Line 1131 | Line 1173 | _ASBOX
1173        for ac_var in $ac_subst_files
1174        do
1175          eval ac_val=$`echo $ac_var`
1176 <        echo "$ac_var='"'"'$ac_val'"'"'"
1176 >        echo "$ac_var='"'"'$ac_val'"'"'"
1177        done | sort
1178        echo
1179      fi
# Line 1150 | Line 1192 | _ASBOX
1192        echo "$as_me: caught signal $ac_signal"
1193      echo "$as_me: exit $exit_status"
1194    } >&5
1195 <  rm -f core core.* *.core &&
1195 >  rm -f core *.core &&
1196    rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1197      exit $exit_status
1198       ' 0
# Line 1230 | Line 1272 | for ac_var in `(set) 2>&1 |
1272   # value.
1273   ac_cache_corrupted=false
1274   for ac_var in `(set) 2>&1 |
1275 <               sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1275 >               sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1276    eval ac_old_set=\$ac_cv_env_${ac_var}_set
1277    eval ac_new_set=\$ac_env_${ac_var}_set
1278    eval ac_old_val="\$ac_cv_env_${ac_var}_value"
# Line 1247 | Line 1289 | echo "$as_me: error: \`$ac_var' was not set in the pre
1289      ,);;
1290      *)
1291        if test "x$ac_old_val" != "x$ac_new_val"; then
1292 <        { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1292 >        { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1293   echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1294 <        { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1294 >        { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1295   echo "$as_me:   former value:  $ac_old_val" >&2;}
1296 <        { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1296 >        { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1297   echo "$as_me:   current value: $ac_new_val" >&2;}
1298 <        ac_cache_corrupted=:
1298 >        ac_cache_corrupted=:
1299        fi;;
1300    esac
1301    # Pass precious variables to config.status.
# Line 1333 | Line 1375 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1375   ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1376   ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1377   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1336
1337
1338 # This file is part of Autoconf.                       -*- Autoconf -*-
1339 # Programming languages support.
1340 # Copyright 2000, 2001
1341 # Free Software Foundation, Inc.
1342 #
1343 # This program is free software; you can redistribute it and/or modify
1344 # it under the terms of the GNU General Public License as published by
1345 # the Free Software Foundation; either version 2, or (at your option)
1346 # any later version.
1347 #
1348 # This program is distributed in the hope that it will be useful,
1349 # but WITHOUT ANY WARRANTY; without even the implied warranty of
1350 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1351 # GNU General Public License for more details.
1352 #
1353 # You should have received a copy of the GNU General Public License
1354 # along with this program; if not, write to the Free Software
1355 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1356 # 02111-1307, USA.
1357 #
1358 # As a special exception, the Free Software Foundation gives unlimited
1359 # permission to copy, distribute and modify the configure scripts that
1360 # are the output of Autoconf.  You need not follow the terms of the GNU
1361 # General Public License when using or distributing such scripts, even
1362 # though portions of the text of Autoconf appear in them.  The GNU
1363 # General Public License (GPL) does govern all other use of the material
1364 # that constitutes the Autoconf program.
1365 #
1366 # Certain portions of the Autoconf source text are designed to be copied
1367 # (in certain cases, depending on the input) into the output of
1368 # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1369 # source text consists of comments plus executable code that decides which
1370 # of the data portions to output in any given case.  We call these
1371 # comments and executable code the "non-data" portions.  Autoconf never
1372 # copies any of the non-data portions into its output.
1373 #
1374 # This special exception to the GPL applies to versions of Autoconf
1375 # released by the Free Software Foundation.  When you make and
1376 # distribute a modified version of Autoconf, you may extend this special
1377 # exception to the GPL to apply to your modified version as well, *unless*
1378 # your modified version has the potential to copy into its output some
1379 # of the text that was the non-data portion of the version that you started
1380 # with.  (In other words, unless your change moves or copies text from
1381 # the non-data portions to the data portions.)  If your modification has
1382 # such potential, you must delete any notice of this special exception
1383 # to the GPL from your modified version.
1384 #
1385 # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1386 # many others).
1378  
1379  
1380 < # Table of Contents:
1390 < #
1391 < # 1. Language selection
1392 < #    and routines to produce programs in a given language.
1393 < #  a. Fortran 77 (to be moved from aclang.m4)
1394 < #  b. Fortran 90
1395 < #  c. Fortran 95
1396 < #
1397 < # 2. Producing programs in a given language.
1398 < #  a. Fortran 77 (to be moved from aclang.m4)
1399 < #  b. Fortran 90
1400 < #  c. Fortran 95
1401 < #
1402 < # 3. Looking for a compiler
1403 < #    And possibly the associated preprocessor.
1404 < #  a. Fortran 77 (to be moved from aclang.m4)
1405 < #  b. Fortran 90
1406 < #  c. Fortran 95
1407 < #
1408 < # 4. Compilers' characteristics.
1409 < #  a. Fortran 77 (to be moved from aclang.m4)
1410 < #  b. Fortran 90
1411 < #  c. Fortran 95
1380 >          ac_config_headers="$ac_config_headers src/config.h"
1381  
1413 # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1414 # ---------------------------------------------------------------------------
1415 #
1416 # Processing the elements of a list is tedious in shell programming,
1417 # as lists tend to be implemented as space delimited strings.
1418 #
1419 # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1420 # if ELEMENT is a member of LIST, otherwise it executes
1421 # ACTION-IF-NOT-FOUND.
1422 # _AC_LIST_MEMBER_IF
1382  
1383  
1384  
1426 # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1427 # -------------------------------------------------
1428 #
1429 # Specifying options to the compiler (whether it be the C, C++ or
1430 # Fortran 77 compiler) that are meant for the linker is compiler
1431 # dependent.  This macro lets you give options to the compiler that
1432 # are meant for the linker in a portable, compiler-independent way.
1433 #
1434 # This macro take two arguments, a list of linker options that the
1435 # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1436 # a shell variable (SHELL-VARIABLE).  The list of linker options are
1437 # appended to the shell variable in a compiler-dependent way.
1438 #
1439 # For example, if the selected language is C, then this:
1440 #
1441 #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1442 #
1443 # will expand into this if the selected C compiler is gcc:
1444 #
1445 #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1446 #
1447 # otherwise, it will expand into this:
1448 #
1449 #   foo_LDFLAGS"-R /usr/local/lib/foo"
1450 #
1451 # You are encouraged to add support for compilers that this macro
1452 # doesn't currently support.
1453 # FIXME: Get rid of this macro.
1454 # _AC_LINKER_OPTION
1385  
1386  
1387  
1458 ## ----------------------- ##
1459 ## 1. Language selection.  ##
1460 ## ----------------------- ##
1388  
1462 # ----------------------------- #
1463 # 1b. The Fortran 90 language.  #
1464 # ----------------------------- #
1389  
1466 # AC_LANG(Fortran 90)
1467 # -------------------
1390  
1391  
1392  
1471 # _AC_LANG_ABBREV(Fortran 90)
1472 # ---------------------------
1393  
1394  
1395  
1476 # ----------------------------- #
1477 # 1c. The Fortran 95 language.  #
1478 # ----------------------------- #
1396  
1480 # AC_LANG(Fortran 95)
1481 # -------------------
1397  
1398  
1399  
1485 # _AC_LANG_ABBREV(Fortran 95)
1486 # ---------------------------
1400  
1401  
1402  
1490 ## ---------------------- ##
1491 ## 2.Producing programs.  ##
1492 ## ---------------------- ##
1403  
1494 # ------------------------ #
1495 # 2b. Fortran 90 sources.  #
1496 # ------------------------ #
1404  
1498 # AC_LANG_SOURCE(Fortran 90)(BODY)
1499 # --------------------------------
1405  
1406  
1407  
1503 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1504 # -----------------------------------------------
1408  
1409  
1507 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1508 # --------------------------------------------
1410  
1411  
1412  
1512 # ------------------------ #
1513 # 2c. Fortran 95 sources.  #
1514 # ------------------------ #
1413  
1516 # AC_LANG_SOURCE(Fortran 95)(BODY)
1517 # --------------------------------
1414  
1415  
1520 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1521 # -----------------------------------------------
1416  
1417 <
1418 < # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1419 < # --------------------------------------------
1420 <
1421 <
1422 <
1423 < ## -------------------------------------------- ##
1530 < ## 3. Looking for Compilers and Preprocessors.  ##
1531 < ## -------------------------------------------- ##
1532 <
1533 < # ----------------------------- #
1534 < # 3b. The Fortran 90 compiler.  #
1535 < # ----------------------------- #
1536 <
1537 <
1538 < # AC_LANG_PREPROC(Fortran 90)
1539 < # ---------------------------
1540 < # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1541 <
1542 <
1543 <
1544 < # AC_LANG_COMPILER(Fortran 90)
1545 < # ----------------------------
1546 < # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1547 < # AC_REQUIRE'able.
1548 <
1549 <
1550 <
1551 < # AC_PROG_F90([COMPILERS...])
1552 < # ---------------------------
1553 < # COMPILERS is a space separated list of Fortran 90 compilers to search
1554 < # for.
1555 < #
1556 < # Compilers are ordered by
1557 < #  1. F90, F95
1558 < #  2. Good/tested native compilers, bad/untested native compilers
1559 < #
1560 < # pgf90 is the Portland Group F90 compilers.
1561 < # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1562 < # lf95 is the Lahey-Fujitsu compiler.
1563 < # epcf90 is the "Edinburgh Portable Compiler" F90.
1564 < # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1565 < # AC_PROG_F90
1566 <
1567 <
1568 < # ----------------------------- #
1569 < # 3c. The Fortran 95 compiler.  #
1570 < # ----------------------------- #
1571 <
1572 <
1573 < # AC_LANG_PREPROC(Fortran 95)
1574 < # ---------------------------
1575 < # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1576 <
1577 <
1578 <
1579 < # AC_LANG_COMPILER(Fortran 95)
1580 < # ----------------------------
1581 < # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1582 < # AC_REQUIRE'able.
1583 <
1584 <
1585 <
1586 < # AC_PROG_F95([COMPILERS...])
1587 < # ---------------------------
1588 < # COMPILERS is a space separated list of Fortran 95 compilers to search
1589 < # for.
1590 < #
1591 < # Compilers are ordered by
1592 < #  1. Good/tested native compilers, bad/untested native compilers
1593 < #
1594 < # xlf95 is the IBM (AIX) F95 compiler.
1595 < # lf95 is the Lahey-Fujitsu compiler.
1596 < # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1597 < # AC_PROG_F95
1598 <
1599 <
1600 < ## ------------------------------- ##
1601 < ## 4. Compilers' characteristics.  ##
1602 < ## ------------------------------- ##
1603 <
1604 <
1605 < # ---------------------------------------- #
1606 < # 4b. Fortan 90 compiler characteristics.  #
1607 < # ---------------------------------------- #
1608 <
1609 <
1610 < # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1611 < # -------------------------------------------------
1612 < # Link a trivial Fortran program, compiling with a verbose output FLAG
1613 < # (which default value, $ac_cv_prog_f90_v, is computed by
1614 < # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1615 < # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1616 < # so that any link flags that are echoed by the compiler appear as
1617 < # space-separated items.
1618 < # _AC_PROG_F90_V_OUTPUT
1619 <
1620 <
1621 < # _AC_PROG_F90_V
1622 < # --------------
1623 < #
1624 < # Determine the flag that causes the Fortran 90 compiler to print
1625 < # information of library and object files (normally -v)
1626 < # Needed for AC_F90_LIBRARY_FLAGS
1627 < # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1628 < # _AC_PROG_F90_V
1629 <
1630 <
1631 < # AC_F90_LIBRARY_LDFLAGS
1632 < # ----------------------
1633 < #
1634 < # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1635 < # intrinsic and run-time libraries that are required to successfully
1636 < # link a Fortran 90 program or shared library.  The output variable
1637 < # F90LIBS is set to these flags.
1638 < #
1639 < # This macro is intended to be used in those situations when it is
1640 < # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1641 < # program or shared library.
1642 < #
1643 < # For example, if object files from a C++ and Fortran 90 compiler must
1644 < # be linked together, then the C++ compiler/linker must be used for
1645 < # linking (since special C++-ish things need to happen at link time
1646 < # like calling global constructors, instantiating templates, enabling
1647 < # exception support, etc.).
1648 < #
1649 < # However, the Fortran 90 intrinsic and run-time libraries must be
1650 < # linked in as well, but the C++ compiler/linker doesn't know how to
1651 < # add these Fortran 90 libraries.  Hence, the macro
1652 < # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1653 < # libraries.
1654 < #
1655 < # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1656 < # AC_F90_LIBRARY_LDFLAGS
1657 <
1658 <
1659 < # _AC_F90_NAME_MANGLING
1660 < # ---------------------
1661 < # Test for the name mangling scheme used by the Fortran 90 compiler.
1662 < #
1663 < # Sets ac_cv_f90_mangling. The value contains three fields, separated
1664 < # by commas:
1665 < #
1666 < # lower case / upper case:
1667 < #    case translation of the Fortan 90 symbols
1668 < # underscore / no underscore:
1669 < #    whether the compiler appends "_" to symbol names
1670 < # extra underscore / no extra underscore:
1671 < #    whether the compiler appends an extra "_" to symbol names already
1672 < #    containing at least one underscore
1673 < #
1674 < # _AC_F90_NAME_MANGLING
1675 <
1676 < # The replacement is empty.
1677 <
1678 <
1679 <
1680 < # AC_F90_WRAPPERS
1681 < # ---------------
1682 < # Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1683 < # properly mangle the names of C identifiers, and C identifiers with
1684 < # underscores, respectively, so that they match the name mangling
1685 < # scheme used by the Fortran 90 compiler.
1686 < # AC_F90_WRAPPERS
1417 > # ACX_CHECK_FFTW()
1418 > # ----------------
1419 > # This macro checks for fftw header files and libraries,
1420 > # including the possible prefixing with s or d to determine precision.
1421 > # Arg 1 is the fftw header/library name to check for, without
1422 > # prefix or anything else (e.g. rfftw_mpi for real MPI transforms)
1423 > # Arg 2 is the size of the real variable used.
1424  
1425  
1689 # AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1690 # ------------------------------------
1691 # For a Fortran subroutine of given NAME, define a shell variable
1692 # $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1693 # argument is not supplied, it defaults to NAME.
1694 # AC_F90_FUNC
1426  
1427  
1697 # ---------------------------------------- #
1698 # 4c. Fortan 95 compiler characteristics.  #
1699 # ---------------------------------------- #
1428  
1429  
1702 # _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1703 # -------------------------------------------------
1704 # Link a trivial Fortran program, compiling with a verbose output FLAG
1705 # (which default value, $ac_cv_prog_f95_v, is computed by
1706 # _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1707 # output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1708 # so that any link flags that are echoed by the compiler appear as
1709 # space-separated items.
1710 # _AC_PROG_F95_V_OUTPUT
1430  
1431  
1713 # _AC_PROG_F95_V
1714 # --------------
1715 #
1716 # Determine the flag that causes the Fortran 95 compiler to print
1717 # information of library and object files (normally -v)
1718 # Needed for AC_F95_LIBRARY_FLAGS
1719 # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1720 # _AC_PROG_F95_V
1432  
1433  
1723 # AC_F95_LIBRARY_LDFLAGS
1724 # ----------------------
1725 #
1726 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1727 # intrinsic and run-time libraries that are required to successfully
1728 # link a Fortran 95 program or shared library.  The output variable
1729 # F95LIBS is set to these flags.
1730 #
1731 # This macro is intended to be used in those situations when it is
1732 # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1733 # program or shared library.
1734 #
1735 # For example, if object files from a C++ and Fortran 95 compiler must
1736 # be linked together, then the C++ compiler/linker must be used for
1737 # linking (since special C++-ish things need to happen at link time
1738 # like calling global constructors, instantiating templates, enabling
1739 # exception support, etc.).
1740 #
1741 # However, the Fortran 95 intrinsic and run-time libraries must be
1742 # linked in as well, but the C++ compiler/linker doesn't know how to
1743 # add these Fortran 95 libraries.  Hence, the macro
1744 # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1745 # libraries.
1746 #
1747 # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1748 # AC_F95_LIBRARY_LDFLAGS
1434  
1435  
1751 # _AC_F95_NAME_MANGLING
1752 # ---------------------
1753 # Test for the name mangling scheme used by the Fortran 95 compiler.
1436   #
1755 # Sets ac_cv_f95_mangling. The value contains three fields, separated
1756 # by commas:
1437   #
1758 # lower case / upper case:
1759 #    case translation of the Fortan 95 symbols
1760 # underscore / no underscore:
1761 #    whether the compiler appends "_" to symbol names
1762 # extra underscore / no extra underscore:
1763 #    whether the compiler appends an extra "_" to symbol names already
1764 #    containing at least one underscore
1438   #
1766 # _AC_F95_NAME_MANGLING
1439  
1768 # The replacement is empty.
1440  
1770
1771
1772 # AC_F95_WRAPPERS
1773 # ---------------
1774 # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1775 # properly mangle the names of C identifiers, and C identifiers with
1776 # underscores, respectively, so that they match the name mangling
1777 # scheme used by the Fortran 95 compiler.
1778 # AC_F95_WRAPPERS
1779
1780
1781 # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1782 # ------------------------------------
1783 # For a Fortran subroutine of given NAME, define a shell variable
1784 # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1785 # argument is not supplied, it defaults to NAME.
1786 # AC_F95_FUNC
1787
1441   # AC_F90_MODULE_NAMES
1442   # -------------------
1443   #
# Line 1827 | Line 1480 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1480  
1481  
1482  
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853 # set program name
1854 PROGNAME="oopse"
1855
1856
1857 # there are two ways to do debugging.  One with the --enable-debug flag
1858 # and one using the DEBUG environment variable
1859
1860 debug=0
1861 # Check whether --enable-debug or --disable-debug was given.
1862 if test "${enable_debug+set}" = set; then
1863  enableval="$enable_debug"
1864  debug=1
1865 fi;
1866 if test "${DEBUG}"; then
1867
1868 cat >>confdefs.h <<\_ACEOF
1869 #define debug 1
1870 _ACEOF
1871
1872  msg="$msg, debug mode"
1873 fi
1874
1875
1483   # who am i
1484   # Make sure we can run config.sub.
1485   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 1931 | Line 1538 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1538  
1539  
1540  
1541 < ac_ext=c
1542 < ac_cpp='$CPP $CPPFLAGS'
1543 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1544 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1545 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1541 > # set program name
1542 > PROGNAME="oopse"
1543 >
1544 >
1545 >
1546 >
1547 > OBJEXT=".$OBJEXT"
1548 >
1549 > OOPSE=oopse
1550 >
1551 > if test "x${prefix}" = "xNONE"
1552 > then
1553 >  OOPSE_HOME=${ac_default_prefix}/oopse
1554 > else
1555 >  OOPSE_HOME=${prefix}/oopse
1556 > fi
1557 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1558 > if test "${enable_oopse_home+set}" = set; then
1559 >  enableval="$enable_oopse_home"
1560 >  OOPSE_HOME="${enableval}"
1561 > fi;
1562 >
1563 > # there are two ways to do debugging.  One with the --enable-debug flag
1564 > # and one using the DEBUG environment variable
1565 >
1566 > debug=0
1567 > # Check whether --enable-debug or --disable-debug was given.
1568 > if test "${enable_debug+set}" = set; then
1569 >  enableval="$enable_debug"
1570 >  debug=1
1571 > fi;
1572 > if test "${DEBUG}"; then
1573 >
1574 > cat >>confdefs.h <<\_ACEOF
1575 > #define debug 1
1576 > _ACEOF
1577 >
1578 >  msg="$msg, debug mode"
1579 > fi
1580 >
1581 >
1582 > # Checks for programs.
1583 > ac_ext=cc
1584 > ac_cpp='$CXXCPP $CPPFLAGS'
1585 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1586 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1587 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1588   if test -n "$ac_tool_prefix"; then
1589 <  for ac_prog in icc xlc gcc cc
1589 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1590    do
1591      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1592   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1593   echo "$as_me:$LINENO: checking for $ac_word" >&5
1594   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1595 < if test "${ac_cv_prog_CC+set}" = set; then
1595 > if test "${ac_cv_prog_CXX+set}" = set; then
1596    echo $ECHO_N "(cached) $ECHO_C" >&6
1597   else
1598 <  if test -n "$CC"; then
1599 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1598 >  if test -n "$CXX"; then
1599 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1600   else
1601   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1602   for as_dir in $PATH
# Line 1956 | Line 1605 | do
1605    test -z "$as_dir" && as_dir=.
1606    for ac_exec_ext in '' $ac_executable_extensions; do
1607    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1608 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1608 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1609      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1610      break 2
1611    fi
# Line 1965 | Line 1614 | fi
1614  
1615   fi
1616   fi
1617 < CC=$ac_cv_prog_CC
1618 < if test -n "$CC"; then
1619 <  echo "$as_me:$LINENO: result: $CC" >&5
1620 < echo "${ECHO_T}$CC" >&6
1617 > CXX=$ac_cv_prog_CXX
1618 > if test -n "$CXX"; then
1619 >  echo "$as_me:$LINENO: result: $CXX" >&5
1620 > echo "${ECHO_T}$CXX" >&6
1621   else
1622    echo "$as_me:$LINENO: result: no" >&5
1623   echo "${ECHO_T}no" >&6
1624   fi
1625  
1626 <    test -n "$CC" && break
1626 >    test -n "$CXX" && break
1627    done
1628   fi
1629 < if test -z "$CC"; then
1630 <  ac_ct_CC=$CC
1631 <  for ac_prog in icc xlc gcc cc
1629 > if test -z "$CXX"; then
1630 >  ac_ct_CXX=$CXX
1631 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1632   do
1633    # Extract the first word of "$ac_prog", so it can be a program name with args.
1634   set dummy $ac_prog; ac_word=$2
1635   echo "$as_me:$LINENO: checking for $ac_word" >&5
1636   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1637 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1637 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1638    echo $ECHO_N "(cached) $ECHO_C" >&6
1639   else
1640 <  if test -n "$ac_ct_CC"; then
1641 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1640 >  if test -n "$ac_ct_CXX"; then
1641 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1642   else
1643   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1644   for as_dir in $PATH
# Line 1998 | Line 1647 | do
1647    test -z "$as_dir" && as_dir=.
1648    for ac_exec_ext in '' $ac_executable_extensions; do
1649    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1650 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1650 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1651      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1652      break 2
1653    fi
# Line 2007 | Line 1656 | fi
1656  
1657   fi
1658   fi
1659 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1660 < if test -n "$ac_ct_CC"; then
1661 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1662 < echo "${ECHO_T}$ac_ct_CC" >&6
1659 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1660 > if test -n "$ac_ct_CXX"; then
1661 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1662 > echo "${ECHO_T}$ac_ct_CXX" >&6
1663   else
1664    echo "$as_me:$LINENO: result: no" >&5
1665   echo "${ECHO_T}no" >&6
1666   fi
1667  
1668 <  test -n "$ac_ct_CC" && break
1668 >  test -n "$ac_ct_CXX" && break
1669   done
1670 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1671  
1672 <  CC=$ac_ct_CC
1672 >  CXX=$ac_ct_CXX
1673   fi
1674  
1675  
2026 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2027 See \`config.log' for more details." >&5
2028 echo "$as_me: error: no acceptable C compiler found in \$PATH
2029 See \`config.log' for more details." >&2;}
2030   { (exit 1); exit 1; }; }
2031
1676   # Provide some information about the compiler.
1677   echo "$as_me:$LINENO:" \
1678 <     "checking for C compiler version" >&5
1678 >     "checking for C++ compiler version" >&5
1679   ac_compiler=`set X $ac_compile; echo $2`
1680   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1681    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2050 | Line 1694 | cat >conftest.$ac_ext <<_ACEOF
1694    (exit $ac_status); }
1695  
1696   cat >conftest.$ac_ext <<_ACEOF
2053 #line $LINENO "configure"
1697   /* confdefs.h.  */
1698   _ACEOF
1699   cat confdefs.h >>conftest.$ac_ext
# Line 2070 | Line 1713 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1713   # Try to create an executable without -o first, disregard a.out.
1714   # It will help us diagnose broken compilers, and finding out an intuition
1715   # of exeext.
1716 < echo "$as_me:$LINENO: checking for C compiler default output" >&5
1717 < echo $ECHO_N "checking for C compiler default output... $ECHO_C" >&6
1716 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1717 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1718   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1719   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1720    (eval $ac_link_default) 2>&5
# Line 2091 | Line 1734 | do
1734    test -f "$ac_file" || continue
1735    case $ac_file in
1736      *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
1737 <        ;;
1737 >        ;;
1738      conftest.$ac_ext )
1739 <        # This is the source file.
1740 <        ;;
1741 <    [ab].out )
1742 <        # We found the default executable, but exeext='' is most
1743 <        # certainly right.
1744 <        break;;
1739 >        # This is the source file.
1740 >        ;;
1741 >    [ab].out )
1742 >        # We found the default executable, but exeext='' is most
1743 >        # certainly right.
1744 >        break;;
1745      *.* )
1746 <        ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
1747 <        # FIXME: I believe we export ac_cv_exeext for Libtool,
1748 <        # but it would be cool to find out if it's true.  Does anybody
1749 <        # maintain Libtool? --akim.
1750 <        export ac_cv_exeext
1751 <        break;;
1746 >        ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
1747 >        # FIXME: I believe we export ac_cv_exeext for Libtool,
1748 >        # but it would be cool to find out if it's true.  Does anybody
1749 >        # maintain Libtool? --akim.
1750 >        export ac_cv_exeext
1751 >        break;;
1752      * )
1753 <        break;;
1753 >        break;;
1754    esac
1755   done
1756   else
1757    echo "$as_me: failed program was:" >&5
1758   sed 's/^/| /' conftest.$ac_ext >&5
1759  
1760 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1760 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1761   See \`config.log' for more details." >&5
1762 < echo "$as_me: error: C compiler cannot create executables
1762 > echo "$as_me: error: C++ compiler cannot create executables
1763   See \`config.log' for more details." >&2;}
1764     { (exit 77); exit 77; }; }
1765   fi
# Line 2127 | Line 1770 | echo "${ECHO_T}$ac_file" >&6
1770  
1771   # Check the compiler produces executables we can run.  If not, either
1772   # the compiler is broken, or we cross compile.
1773 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1774 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1773 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1774 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1775   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1776   # If not cross compiling, check that we can run a simple program.
1777   if test "$cross_compiling" != yes; then
# Line 2143 | Line 1786 | if test "$cross_compiling" != yes; then
1786      if test "$cross_compiling" = maybe; then
1787          cross_compiling=yes
1788      else
1789 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1789 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1790   If you meant to cross compile, use \`--host'.
1791   See \`config.log' for more details." >&5
1792 < echo "$as_me: error: cannot run C compiled programs.
1792 > echo "$as_me: error: cannot run C++ compiled programs.
1793   If you meant to cross compile, use \`--host'.
1794   See \`config.log' for more details." >&2;}
1795     { (exit 1); exit 1; }; }
# Line 2181 | Line 1824 | for ac_file in conftest.exe conftest conftest.*; do
1824    case $ac_file in
1825      *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
1826      *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
1827 <          export ac_cv_exeext
1828 <          break;;
1827 >          export ac_cv_exeext
1828 >          break;;
1829      * ) break;;
1830    esac
1831   done
# Line 2207 | Line 1850 | else
1850    echo $ECHO_N "(cached) $ECHO_C" >&6
1851   else
1852    cat >conftest.$ac_ext <<_ACEOF
2210 #line $LINENO "configure"
1853   /* confdefs.h.  */
1854   _ACEOF
1855   cat confdefs.h >>conftest.$ac_ext
# Line 2252 | Line 1894 | ac_objext=$OBJEXT
1894   echo "${ECHO_T}$ac_cv_objext" >&6
1895   OBJEXT=$ac_cv_objext
1896   ac_objext=$OBJEXT
1897 < echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
1898 < echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
1899 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
1897 > echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1898 > echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1899 > if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1900    echo $ECHO_N "(cached) $ECHO_C" >&6
1901   else
1902    cat >conftest.$ac_ext <<_ACEOF
2261 #line $LINENO "configure"
1903   /* confdefs.h.  */
1904   _ACEOF
1905   cat confdefs.h >>conftest.$ac_ext
# Line 2278 | Line 1919 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1919   _ACEOF
1920   rm -f conftest.$ac_objext
1921   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1922 <  (eval $ac_compile) 2>&5
1922 >  (eval $ac_compile) 2>conftest.er1
1923    ac_status=$?
1924 +  grep -v '^ *+' conftest.er1 >conftest.err
1925 +  rm -f conftest.er1
1926 +  cat conftest.err >&5
1927    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1928    (exit $ac_status); } &&
1929 <         { ac_try='test -s conftest.$ac_objext'
1929 >         { ac_try='test -z "$ac_cxx_werror_flag"
1930 >                         || test ! -s conftest.err'
1931    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1932    (eval $ac_try) 2>&5
1933    ac_status=$?
1934    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1935 +  (exit $ac_status); }; } &&
1936 +         { ac_try='test -s conftest.$ac_objext'
1937 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1938 +  (eval $ac_try) 2>&5
1939 +  ac_status=$?
1940 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1941    (exit $ac_status); }; }; then
1942    ac_compiler_gnu=yes
1943   else
# Line 2295 | Line 1946 | fi
1946  
1947   ac_compiler_gnu=no
1948   fi
1949 < rm -f conftest.$ac_objext conftest.$ac_ext
1950 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
1949 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1950 > ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
1951  
1952   fi
1953 < echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
1954 < echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
1955 < GCC=`test $ac_compiler_gnu = yes && echo yes`
1956 < ac_test_CFLAGS=${CFLAGS+set}
1957 < ac_save_CFLAGS=$CFLAGS
1958 < CFLAGS="-g"
1959 < echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
1960 < echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
1961 < if test "${ac_cv_prog_cc_g+set}" = set; then
1953 > echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
1954 > echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
1955 > GXX=`test $ac_compiler_gnu = yes && echo yes`
1956 > ac_test_CXXFLAGS=${CXXFLAGS+set}
1957 > ac_save_CXXFLAGS=$CXXFLAGS
1958 > CXXFLAGS="-g"
1959 > echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
1960 > echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
1961 > if test "${ac_cv_prog_cxx_g+set}" = set; then
1962    echo $ECHO_N "(cached) $ECHO_C" >&6
1963   else
1964    cat >conftest.$ac_ext <<_ACEOF
2314 #line $LINENO "configure"
1965   /* confdefs.h.  */
1966   _ACEOF
1967   cat confdefs.h >>conftest.$ac_ext
# Line 2328 | Line 1978 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1978   _ACEOF
1979   rm -f conftest.$ac_objext
1980   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1981 <  (eval $ac_compile) 2>&5
1981 >  (eval $ac_compile) 2>conftest.er1
1982    ac_status=$?
1983 +  grep -v '^ *+' conftest.er1 >conftest.err
1984 +  rm -f conftest.er1
1985 +  cat conftest.err >&5
1986    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1987    (exit $ac_status); } &&
1988 <         { ac_try='test -s conftest.$ac_objext'
1988 >         { ac_try='test -z "$ac_cxx_werror_flag"
1989 >                         || test ! -s conftest.err'
1990    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1991    (eval $ac_try) 2>&5
1992    ac_status=$?
1993    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1994 +  (exit $ac_status); }; } &&
1995 +         { ac_try='test -s conftest.$ac_objext'
1996 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1997 +  (eval $ac_try) 2>&5
1998 +  ac_status=$?
1999 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2000    (exit $ac_status); }; }; then
2001 <  ac_cv_prog_cc_g=yes
2001 >  ac_cv_prog_cxx_g=yes
2002   else
2003    echo "$as_me: failed program was:" >&5
2004   sed 's/^/| /' conftest.$ac_ext >&5
2005  
2006 < ac_cv_prog_cc_g=no
2006 > ac_cv_prog_cxx_g=no
2007   fi
2008 < rm -f conftest.$ac_objext conftest.$ac_ext
2008 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2009   fi
2010 < echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2011 < echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2012 < if test "$ac_test_CFLAGS" = set; then
2013 <  CFLAGS=$ac_save_CFLAGS
2014 < elif test $ac_cv_prog_cc_g = yes; then
2015 <  if test "$GCC" = yes; then
2016 <    CFLAGS="-g -O2"
2010 > echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2011 > echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2012 > if test "$ac_test_CXXFLAGS" = set; then
2013 >  CXXFLAGS=$ac_save_CXXFLAGS
2014 > elif test $ac_cv_prog_cxx_g = yes; then
2015 >  if test "$GXX" = yes; then
2016 >    CXXFLAGS="-g -O2"
2017    else
2018 <    CFLAGS="-g"
2018 >    CXXFLAGS="-g"
2019    fi
2020   else
2021 <  if test "$GCC" = yes; then
2022 <    CFLAGS="-O2"
2021 >  if test "$GXX" = yes; then
2022 >    CXXFLAGS="-O2"
2023    else
2024 <    CFLAGS=
2024 >    CXXFLAGS=
2025    fi
2026   fi
2027 < echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2028 < echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2029 < if test "${ac_cv_prog_cc_stdc+set}" = set; then
2030 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2031 < else
2032 <  ac_cv_prog_cc_stdc=no
2033 < ac_save_CC=$CC
2034 < cat >conftest.$ac_ext <<_ACEOF
2035 < #line $LINENO "configure"
2027 > for ac_declaration in \
2028 >   '' \
2029 >   'extern "C" void std::exit (int) throw (); using std::exit;' \
2030 >   'extern "C" void std::exit (int); using std::exit;' \
2031 >   'extern "C" void exit (int) throw ();' \
2032 >   'extern "C" void exit (int);' \
2033 >   'void exit (int);'
2034 > do
2035 >  cat >conftest.$ac_ext <<_ACEOF
2036   /* confdefs.h.  */
2037   _ACEOF
2038   cat confdefs.h >>conftest.$ac_ext
2039   cat >>conftest.$ac_ext <<_ACEOF
2040   /* end confdefs.h.  */
2041 < #include <stdarg.h>
2042 < #include <stdio.h>
2383 < #include <sys/types.h>
2384 < #include <sys/stat.h>
2385 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2386 < struct buf { int x; };
2387 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
2388 < static char *e (p, i)
2389 <     char **p;
2390 <     int i;
2391 < {
2392 <  return p[i];
2393 < }
2394 < static char *f (char * (*g) (char **, int), char **p, ...)
2395 < {
2396 <  char *s;
2397 <  va_list v;
2398 <  va_start (v,p);
2399 <  s = g (p, va_arg (v,int));
2400 <  va_end (v);
2401 <  return s;
2402 < }
2403 < int test (int i, double x);
2404 < struct s1 {int (*f) (int a);};
2405 < struct s2 {int (*f) (double a);};
2406 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2407 < int argc;
2408 < char **argv;
2041 > $ac_declaration
2042 > #include <stdlib.h>
2043   int
2044   main ()
2045   {
2046 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2046 > exit (42);
2047    ;
2048    return 0;
2049   }
2050   _ACEOF
2051 < # Don't try gcc -ansi; that turns off useful extensions and
2418 < # breaks some systems' header files.
2419 < # AIX                   -qlanglvl=ansi
2420 < # Ultrix and OSF/1      -std1
2421 < # HP-UX 10.20 and later -Ae
2422 < # HP-UX older versions  -Aa -D_HPUX_SOURCE
2423 < # SVR4                  -Xc -D__EXTENSIONS__
2424 < for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2425 < do
2426 <  CC="$ac_save_CC $ac_arg"
2427 <  rm -f conftest.$ac_objext
2051 > rm -f conftest.$ac_objext
2052   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2053 <  (eval $ac_compile) 2>&5
2053 >  (eval $ac_compile) 2>conftest.er1
2054    ac_status=$?
2055 +  grep -v '^ *+' conftest.er1 >conftest.err
2056 +  rm -f conftest.er1
2057 +  cat conftest.err >&5
2058    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2059    (exit $ac_status); } &&
2060 <         { ac_try='test -s conftest.$ac_objext'
2060 >         { ac_try='test -z "$ac_cxx_werror_flag"
2061 >                         || test ! -s conftest.err'
2062    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2063    (eval $ac_try) 2>&5
2064    ac_status=$?
2065    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2066 +  (exit $ac_status); }; } &&
2067 +         { ac_try='test -s conftest.$ac_objext'
2068 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2069 +  (eval $ac_try) 2>&5
2070 +  ac_status=$?
2071 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2072    (exit $ac_status); }; }; then
2073 <  ac_cv_prog_cc_stdc=$ac_arg
2440 < break
2073 >  :
2074   else
2075    echo "$as_me: failed program was:" >&5
2076   sed 's/^/| /' conftest.$ac_ext >&5
2077  
2078 + continue
2079   fi
2080 < rm -f conftest.$ac_objext
2081 < done
2082 < rm -f conftest.$ac_ext conftest.$ac_objext
2449 < CC=$ac_save_CC
2450 <
2451 < fi
2452 <
2453 < case "x$ac_cv_prog_cc_stdc" in
2454 <  x|xno)
2455 <    echo "$as_me:$LINENO: result: none needed" >&5
2456 < echo "${ECHO_T}none needed" >&6 ;;
2457 <  *)
2458 <    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2459 < echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2460 <    CC="$CC $ac_cv_prog_cc_stdc" ;;
2461 < esac
2462 <
2463 < # Some people use a C++ compiler to compile C.  Since we use `exit',
2464 < # in C++ we need to declare it.  In case someone uses the same compiler
2465 < # for both compiling C and C++ we need to have the C++ compiler decide
2466 < # the declaration of exit, since it's the most demanding environment.
2467 < cat >conftest.$ac_ext <<_ACEOF
2468 < #ifndef __cplusplus
2469 <  choke me
2470 < #endif
2080 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2081 >  cat >conftest.$ac_ext <<_ACEOF
2082 > /* confdefs.h.  */
2083   _ACEOF
2472 rm -f conftest.$ac_objext
2473 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2474  (eval $ac_compile) 2>&5
2475  ac_status=$?
2476  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2477  (exit $ac_status); } &&
2478         { ac_try='test -s conftest.$ac_objext'
2479  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2480  (eval $ac_try) 2>&5
2481  ac_status=$?
2482  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2483  (exit $ac_status); }; }; then
2484  for ac_declaration in \
2485   ''\
2486   '#include <stdlib.h>' \
2487   'extern "C" void std::exit (int) throw (); using std::exit;' \
2488   'extern "C" void std::exit (int); using std::exit;' \
2489   'extern "C" void exit (int) throw ();' \
2490   'extern "C" void exit (int);' \
2491   'void exit (int);'
2492 do
2493  cat >conftest.$ac_ext <<_ACEOF
2494 #line $LINENO "configure"
2495 /* confdefs.h.  */
2496 _ACEOF
2084   cat confdefs.h >>conftest.$ac_ext
2085   cat >>conftest.$ac_ext <<_ACEOF
2086   /* end confdefs.h.  */
2500 #include <stdlib.h>
2087   $ac_declaration
2088   int
2089   main ()
# Line 2509 | Line 2095 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2095   _ACEOF
2096   rm -f conftest.$ac_objext
2097   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2098 <  (eval $ac_compile) 2>&5
2098 >  (eval $ac_compile) 2>conftest.er1
2099    ac_status=$?
2100 +  grep -v '^ *+' conftest.er1 >conftest.err
2101 +  rm -f conftest.er1
2102 +  cat conftest.err >&5
2103    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2104    (exit $ac_status); } &&
2105 <         { ac_try='test -s conftest.$ac_objext'
2105 >         { ac_try='test -z "$ac_cxx_werror_flag"
2106 >                         || test ! -s conftest.err'
2107    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2108    (eval $ac_try) 2>&5
2109    ac_status=$?
2110    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2111 <  (exit $ac_status); }; }; then
2112 <  :
2523 < else
2524 <  echo "$as_me: failed program was:" >&5
2525 < sed 's/^/| /' conftest.$ac_ext >&5
2526 <
2527 < continue
2528 < fi
2529 < rm -f conftest.$ac_objext conftest.$ac_ext
2530 <  cat >conftest.$ac_ext <<_ACEOF
2531 < #line $LINENO "configure"
2532 < /* confdefs.h.  */
2533 < _ACEOF
2534 < cat confdefs.h >>conftest.$ac_ext
2535 < cat >>conftest.$ac_ext <<_ACEOF
2536 < /* end confdefs.h.  */
2537 < $ac_declaration
2538 < int
2539 < main ()
2540 < {
2541 < exit (42);
2542 <  ;
2543 <  return 0;
2544 < }
2545 < _ACEOF
2546 < rm -f conftest.$ac_objext
2547 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2548 <  (eval $ac_compile) 2>&5
2549 <  ac_status=$?
2550 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2551 <  (exit $ac_status); } &&
2552 <         { ac_try='test -s conftest.$ac_objext'
2111 >  (exit $ac_status); }; } &&
2112 >         { ac_try='test -s conftest.$ac_objext'
2113    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2114    (eval $ac_try) 2>&5
2115    ac_status=$?
# Line 2561 | Line 2121 | fi
2121   sed 's/^/| /' conftest.$ac_ext >&5
2122  
2123   fi
2124 < rm -f conftest.$ac_objext conftest.$ac_ext
2124 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2125   done
2126   rm -f conftest*
2127   if test -n "$ac_declaration"; then
# Line 2570 | Line 2130 | fi
2130    echo '#endif'             >>confdefs.h
2131   fi
2132  
2573 else
2574  echo "$as_me: failed program was:" >&5
2575 sed 's/^/| /' conftest.$ac_ext >&5
2576
2577 fi
2578 rm -f conftest.$ac_objext conftest.$ac_ext
2133   ac_ext=c
2134   ac_cpp='$CPP $CPPFLAGS'
2135   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2136   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2137   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2138  
2139 <
2140 < ac_ext=cc
2141 < ac_cpp='$CXXCPP $CPPFLAGS'
2142 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2143 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2590 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2139 > ac_ext=c
2140 > ac_cpp='$CPP $CPPFLAGS'
2141 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2142 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2143 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2144   if test -n "$ac_tool_prefix"; then
2145 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2145 >  for ac_prog in icc pgcc pathcc cc xlc gcc
2146    do
2147      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2148   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2149   echo "$as_me:$LINENO: checking for $ac_word" >&5
2150   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2151 < if test "${ac_cv_prog_CXX+set}" = set; then
2151 > if test "${ac_cv_prog_CC+set}" = set; then
2152    echo $ECHO_N "(cached) $ECHO_C" >&6
2153   else
2154 <  if test -n "$CXX"; then
2155 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2154 >  if test -n "$CC"; then
2155 >  ac_cv_prog_CC="$CC" # Let the user override the test.
2156   else
2157   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2158   for as_dir in $PATH
# Line 2608 | Line 2161 | do
2161    test -z "$as_dir" && as_dir=.
2162    for ac_exec_ext in '' $ac_executable_extensions; do
2163    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2164 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2164 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2165      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2166      break 2
2167    fi
# Line 2617 | Line 2170 | fi
2170  
2171   fi
2172   fi
2173 < CXX=$ac_cv_prog_CXX
2174 < if test -n "$CXX"; then
2175 <  echo "$as_me:$LINENO: result: $CXX" >&5
2176 < echo "${ECHO_T}$CXX" >&6
2173 > CC=$ac_cv_prog_CC
2174 > if test -n "$CC"; then
2175 >  echo "$as_me:$LINENO: result: $CC" >&5
2176 > echo "${ECHO_T}$CC" >&6
2177   else
2178    echo "$as_me:$LINENO: result: no" >&5
2179   echo "${ECHO_T}no" >&6
2180   fi
2181  
2182 <    test -n "$CXX" && break
2182 >    test -n "$CC" && break
2183    done
2184   fi
2185 < if test -z "$CXX"; then
2186 <  ac_ct_CXX=$CXX
2187 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2185 > if test -z "$CC"; then
2186 >  ac_ct_CC=$CC
2187 >  for ac_prog in icc pgcc pathcc cc xlc gcc
2188   do
2189    # Extract the first word of "$ac_prog", so it can be a program name with args.
2190   set dummy $ac_prog; ac_word=$2
2191   echo "$as_me:$LINENO: checking for $ac_word" >&5
2192   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2193 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2193 > if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2194    echo $ECHO_N "(cached) $ECHO_C" >&6
2195   else
2196 <  if test -n "$ac_ct_CXX"; then
2197 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2196 >  if test -n "$ac_ct_CC"; then
2197 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2198   else
2199   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2200   for as_dir in $PATH
# Line 2650 | Line 2203 | do
2203    test -z "$as_dir" && as_dir=.
2204    for ac_exec_ext in '' $ac_executable_extensions; do
2205    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2206 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2206 >    ac_cv_prog_ac_ct_CC="$ac_prog"
2207      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2208      break 2
2209    fi
# Line 2659 | Line 2212 | fi
2212  
2213   fi
2214   fi
2215 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2216 < if test -n "$ac_ct_CXX"; then
2217 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2218 < echo "${ECHO_T}$ac_ct_CXX" >&6
2215 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
2216 > if test -n "$ac_ct_CC"; then
2217 >  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2218 > echo "${ECHO_T}$ac_ct_CC" >&6
2219   else
2220    echo "$as_me:$LINENO: result: no" >&5
2221   echo "${ECHO_T}no" >&6
2222   fi
2223  
2224 <  test -n "$ac_ct_CXX" && break
2224 >  test -n "$ac_ct_CC" && break
2225   done
2673 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2226  
2227 <  CXX=$ac_ct_CXX
2227 >  CC=$ac_ct_CC
2228   fi
2229  
2230  
2231 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2232 + See \`config.log' for more details." >&5
2233 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2234 + See \`config.log' for more details." >&2;}
2235 +   { (exit 1); exit 1; }; }
2236 +
2237   # Provide some information about the compiler.
2238   echo "$as_me:$LINENO:" \
2239 <     "checking for C++ compiler version" >&5
2239 >     "checking for C compiler version" >&5
2240   ac_compiler=`set X $ac_compile; echo $2`
2241   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2242    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2696 | Line 2254 | ac_compiler=`set X $ac_compile; echo $2`
2254    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2255    (exit $ac_status); }
2256  
2257 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2258 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2259 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2257 > echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2258 > echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2259 > if test "${ac_cv_c_compiler_gnu+set}" = set; then
2260    echo $ECHO_N "(cached) $ECHO_C" >&6
2261   else
2262    cat >conftest.$ac_ext <<_ACEOF
2705 #line $LINENO "configure"
2263   /* confdefs.h.  */
2264   _ACEOF
2265   cat confdefs.h >>conftest.$ac_ext
# Line 2722 | Line 2279 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2279   _ACEOF
2280   rm -f conftest.$ac_objext
2281   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2282 <  (eval $ac_compile) 2>&5
2282 >  (eval $ac_compile) 2>conftest.er1
2283    ac_status=$?
2284 +  grep -v '^ *+' conftest.er1 >conftest.err
2285 +  rm -f conftest.er1
2286 +  cat conftest.err >&5
2287    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2288    (exit $ac_status); } &&
2289 <         { ac_try='test -s conftest.$ac_objext'
2289 >         { ac_try='test -z "$ac_c_werror_flag"
2290 >                         || test ! -s conftest.err'
2291    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2292    (eval $ac_try) 2>&5
2293    ac_status=$?
2294    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2295 +  (exit $ac_status); }; } &&
2296 +         { ac_try='test -s conftest.$ac_objext'
2297 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2298 +  (eval $ac_try) 2>&5
2299 +  ac_status=$?
2300 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2301    (exit $ac_status); }; }; then
2302    ac_compiler_gnu=yes
2303   else
# Line 2739 | Line 2306 | fi
2306  
2307   ac_compiler_gnu=no
2308   fi
2309 < rm -f conftest.$ac_objext conftest.$ac_ext
2310 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2309 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2310 > ac_cv_c_compiler_gnu=$ac_compiler_gnu
2311  
2312   fi
2313 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2314 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2315 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2316 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2317 < ac_save_CXXFLAGS=$CXXFLAGS
2318 < CXXFLAGS="-g"
2319 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2320 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2321 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2313 > echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2314 > echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2315 > GCC=`test $ac_compiler_gnu = yes && echo yes`
2316 > ac_test_CFLAGS=${CFLAGS+set}
2317 > ac_save_CFLAGS=$CFLAGS
2318 > CFLAGS="-g"
2319 > echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2320 > echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2321 > if test "${ac_cv_prog_cc_g+set}" = set; then
2322    echo $ECHO_N "(cached) $ECHO_C" >&6
2323   else
2324    cat >conftest.$ac_ext <<_ACEOF
2758 #line $LINENO "configure"
2325   /* confdefs.h.  */
2326   _ACEOF
2327   cat confdefs.h >>conftest.$ac_ext
# Line 2772 | Line 2338 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2338   _ACEOF
2339   rm -f conftest.$ac_objext
2340   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2341 <  (eval $ac_compile) 2>&5
2341 >  (eval $ac_compile) 2>conftest.er1
2342    ac_status=$?
2343 +  grep -v '^ *+' conftest.er1 >conftest.err
2344 +  rm -f conftest.er1
2345 +  cat conftest.err >&5
2346    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2347    (exit $ac_status); } &&
2348 <         { ac_try='test -s conftest.$ac_objext'
2348 >         { ac_try='test -z "$ac_c_werror_flag"
2349 >                         || test ! -s conftest.err'
2350    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2351    (eval $ac_try) 2>&5
2352    ac_status=$?
2353    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2354 +  (exit $ac_status); }; } &&
2355 +         { ac_try='test -s conftest.$ac_objext'
2356 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2357 +  (eval $ac_try) 2>&5
2358 +  ac_status=$?
2359 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2360    (exit $ac_status); }; }; then
2361 <  ac_cv_prog_cxx_g=yes
2361 >  ac_cv_prog_cc_g=yes
2362   else
2363    echo "$as_me: failed program was:" >&5
2364   sed 's/^/| /' conftest.$ac_ext >&5
2365  
2366 < ac_cv_prog_cxx_g=no
2366 > ac_cv_prog_cc_g=no
2367   fi
2368 < rm -f conftest.$ac_objext conftest.$ac_ext
2368 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2369   fi
2370 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2371 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2372 < if test "$ac_test_CXXFLAGS" = set; then
2373 <  CXXFLAGS=$ac_save_CXXFLAGS
2374 < elif test $ac_cv_prog_cxx_g = yes; then
2375 <  if test "$GXX" = yes; then
2376 <    CXXFLAGS="-g -O2"
2370 > echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2371 > echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2372 > if test "$ac_test_CFLAGS" = set; then
2373 >  CFLAGS=$ac_save_CFLAGS
2374 > elif test $ac_cv_prog_cc_g = yes; then
2375 >  if test "$GCC" = yes; then
2376 >    CFLAGS="-g -O2"
2377    else
2378 <    CXXFLAGS="-g"
2378 >    CFLAGS="-g"
2379    fi
2380   else
2381 <  if test "$GXX" = yes; then
2382 <    CXXFLAGS="-O2"
2381 >  if test "$GCC" = yes; then
2382 >    CFLAGS="-O2"
2383    else
2384 <    CXXFLAGS=
2384 >    CFLAGS=
2385    fi
2386   fi
2387 < for ac_declaration in \
2388 <   ''\
2389 <   '#include <stdlib.h>' \
2387 > echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2388 > echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2389 > if test "${ac_cv_prog_cc_stdc+set}" = set; then
2390 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2391 > else
2392 >  ac_cv_prog_cc_stdc=no
2393 > ac_save_CC=$CC
2394 > cat >conftest.$ac_ext <<_ACEOF
2395 > /* confdefs.h.  */
2396 > _ACEOF
2397 > cat confdefs.h >>conftest.$ac_ext
2398 > cat >>conftest.$ac_ext <<_ACEOF
2399 > /* end confdefs.h.  */
2400 > #include <stdarg.h>
2401 > #include <stdio.h>
2402 > #include <sys/types.h>
2403 > #include <sys/stat.h>
2404 > /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2405 > struct buf { int x; };
2406 > FILE * (*rcsopen) (struct buf *, struct stat *, int);
2407 > static char *e (p, i)
2408 >     char **p;
2409 >     int i;
2410 > {
2411 >  return p[i];
2412 > }
2413 > static char *f (char * (*g) (char **, int), char **p, ...)
2414 > {
2415 >  char *s;
2416 >  va_list v;
2417 >  va_start (v,p);
2418 >  s = g (p, va_arg (v,int));
2419 >  va_end (v);
2420 >  return s;
2421 > }
2422 >
2423 > /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2424 >   function prototypes and stuff, but not '\xHH' hex character constants.
2425 >   These don't provoke an error unfortunately, instead are silently treated
2426 >   as 'x'.  The following induces an error, until -std1 is added to get
2427 >   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2428 >   array size at least.  It's necessary to write '\x00'==0 to get something
2429 >   that's true only with -std1.  */
2430 > int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2431 >
2432 > int test (int i, double x);
2433 > struct s1 {int (*f) (int a);};
2434 > struct s2 {int (*f) (double a);};
2435 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2436 > int argc;
2437 > char **argv;
2438 > int
2439 > main ()
2440 > {
2441 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2442 >  ;
2443 >  return 0;
2444 > }
2445 > _ACEOF
2446 > # Don't try gcc -ansi; that turns off useful extensions and
2447 > # breaks some systems' header files.
2448 > # AIX                   -qlanglvl=ansi
2449 > # Ultrix and OSF/1      -std1
2450 > # HP-UX 10.20 and later -Ae
2451 > # HP-UX older versions  -Aa -D_HPUX_SOURCE
2452 > # SVR4                  -Xc -D__EXTENSIONS__
2453 > for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2454 > do
2455 >  CC="$ac_save_CC $ac_arg"
2456 >  rm -f conftest.$ac_objext
2457 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2458 >  (eval $ac_compile) 2>conftest.er1
2459 >  ac_status=$?
2460 >  grep -v '^ *+' conftest.er1 >conftest.err
2461 >  rm -f conftest.er1
2462 >  cat conftest.err >&5
2463 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2464 >  (exit $ac_status); } &&
2465 >         { ac_try='test -z "$ac_c_werror_flag"
2466 >                         || test ! -s conftest.err'
2467 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2468 >  (eval $ac_try) 2>&5
2469 >  ac_status=$?
2470 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2471 >  (exit $ac_status); }; } &&
2472 >         { ac_try='test -s conftest.$ac_objext'
2473 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2474 >  (eval $ac_try) 2>&5
2475 >  ac_status=$?
2476 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2477 >  (exit $ac_status); }; }; then
2478 >  ac_cv_prog_cc_stdc=$ac_arg
2479 > break
2480 > else
2481 >  echo "$as_me: failed program was:" >&5
2482 > sed 's/^/| /' conftest.$ac_ext >&5
2483 >
2484 > fi
2485 > rm -f conftest.err conftest.$ac_objext
2486 > done
2487 > rm -f conftest.$ac_ext conftest.$ac_objext
2488 > CC=$ac_save_CC
2489 >
2490 > fi
2491 >
2492 > case "x$ac_cv_prog_cc_stdc" in
2493 >  x|xno)
2494 >    echo "$as_me:$LINENO: result: none needed" >&5
2495 > echo "${ECHO_T}none needed" >&6 ;;
2496 >  *)
2497 >    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2498 > echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2499 >    CC="$CC $ac_cv_prog_cc_stdc" ;;
2500 > esac
2501 >
2502 > # Some people use a C++ compiler to compile C.  Since we use `exit',
2503 > # in C++ we need to declare it.  In case someone uses the same compiler
2504 > # for both compiling C and C++ we need to have the C++ compiler decide
2505 > # the declaration of exit, since it's the most demanding environment.
2506 > cat >conftest.$ac_ext <<_ACEOF
2507 > #ifndef __cplusplus
2508 >  choke me
2509 > #endif
2510 > _ACEOF
2511 > rm -f conftest.$ac_objext
2512 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2513 >  (eval $ac_compile) 2>conftest.er1
2514 >  ac_status=$?
2515 >  grep -v '^ *+' conftest.er1 >conftest.err
2516 >  rm -f conftest.er1
2517 >  cat conftest.err >&5
2518 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2519 >  (exit $ac_status); } &&
2520 >         { ac_try='test -z "$ac_c_werror_flag"
2521 >                         || test ! -s conftest.err'
2522 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2523 >  (eval $ac_try) 2>&5
2524 >  ac_status=$?
2525 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2526 >  (exit $ac_status); }; } &&
2527 >         { ac_try='test -s conftest.$ac_objext'
2528 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2529 >  (eval $ac_try) 2>&5
2530 >  ac_status=$?
2531 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2532 >  (exit $ac_status); }; }; then
2533 >  for ac_declaration in \
2534 >   '' \
2535     'extern "C" void std::exit (int) throw (); using std::exit;' \
2536     'extern "C" void std::exit (int); using std::exit;' \
2537     'extern "C" void exit (int) throw ();' \
# Line 2818 | Line 2539 | do
2539     'void exit (int);'
2540   do
2541    cat >conftest.$ac_ext <<_ACEOF
2821 #line $LINENO "configure"
2542   /* confdefs.h.  */
2543   _ACEOF
2544   cat confdefs.h >>conftest.$ac_ext
2545   cat >>conftest.$ac_ext <<_ACEOF
2546   /* end confdefs.h.  */
2827 #include <stdlib.h>
2547   $ac_declaration
2548 + #include <stdlib.h>
2549   int
2550   main ()
2551   {
# Line 2836 | Line 2556 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2556   _ACEOF
2557   rm -f conftest.$ac_objext
2558   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2559 <  (eval $ac_compile) 2>&5
2559 >  (eval $ac_compile) 2>conftest.er1
2560    ac_status=$?
2561 +  grep -v '^ *+' conftest.er1 >conftest.err
2562 +  rm -f conftest.er1
2563 +  cat conftest.err >&5
2564    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2565    (exit $ac_status); } &&
2566 <         { ac_try='test -s conftest.$ac_objext'
2566 >         { ac_try='test -z "$ac_c_werror_flag"
2567 >                         || test ! -s conftest.err'
2568    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2569    (eval $ac_try) 2>&5
2570    ac_status=$?
2571    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2572 +  (exit $ac_status); }; } &&
2573 +         { ac_try='test -s conftest.$ac_objext'
2574 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2575 +  (eval $ac_try) 2>&5
2576 +  ac_status=$?
2577 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2578    (exit $ac_status); }; }; then
2579    :
2580   else
# Line 2853 | Line 2583 | fi
2583  
2584   continue
2585   fi
2586 < rm -f conftest.$ac_objext conftest.$ac_ext
2586 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2587    cat >conftest.$ac_ext <<_ACEOF
2858 #line $LINENO "configure"
2588   /* confdefs.h.  */
2589   _ACEOF
2590   cat confdefs.h >>conftest.$ac_ext
# Line 2872 | Line 2601 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2601   _ACEOF
2602   rm -f conftest.$ac_objext
2603   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2604 <  (eval $ac_compile) 2>&5
2604 >  (eval $ac_compile) 2>conftest.er1
2605    ac_status=$?
2606 +  grep -v '^ *+' conftest.er1 >conftest.err
2607 +  rm -f conftest.er1
2608 +  cat conftest.err >&5
2609    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2610    (exit $ac_status); } &&
2611 <         { ac_try='test -s conftest.$ac_objext'
2611 >         { ac_try='test -z "$ac_c_werror_flag"
2612 >                         || test ! -s conftest.err'
2613    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2614    (eval $ac_try) 2>&5
2615    ac_status=$?
2616    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2617 +  (exit $ac_status); }; } &&
2618 +         { ac_try='test -s conftest.$ac_objext'
2619 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2620 +  (eval $ac_try) 2>&5
2621 +  ac_status=$?
2622 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2623    (exit $ac_status); }; }; then
2624    break
2625   else
# Line 2888 | Line 2627 | fi
2627   sed 's/^/| /' conftest.$ac_ext >&5
2628  
2629   fi
2630 < rm -f conftest.$ac_objext conftest.$ac_ext
2630 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2631   done
2632   rm -f conftest*
2633   if test -n "$ac_declaration"; then
# Line 2897 | Line 2636 | fi
2636    echo '#endif'             >>confdefs.h
2637   fi
2638  
2639 + else
2640 +  echo "$as_me: failed program was:" >&5
2641 + sed 's/^/| /' conftest.$ac_ext >&5
2642 +
2643 + fi
2644 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2645   ac_ext=c
2646   ac_cpp='$CPP $CPPFLAGS'
2647   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2648   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2649   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2650  
2651 <
2652 < OOPSE_TEMPLATE_FLAGS=""
2653 < if test $ac_cv_cxx_compiler_gnu = no; then
2654 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
2910 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
2911 <  echo 'void f(){}' > conftest.cc
2912 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
2913 <    echo "$as_me:$LINENO: result: yes" >&5
2914 < echo "${ECHO_T}yes" >&6
2915 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
2916 <  else
2917 <    echo "$as_me:$LINENO: result: no" >&5
2918 < echo "${ECHO_T}no" >&6
2919 <  fi
2920 <  rm -f conftest*
2921 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
2922 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
2923 <  echo 'void f(){}' > conftest.cc
2924 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
2925 <    echo "$as_me:$LINENO: result: yes" >&5
2926 < echo "${ECHO_T}yes" >&6
2927 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
2928 <  else
2929 <    echo "$as_me:$LINENO: result: no" >&5
2930 < echo "${ECHO_T}no" >&6
2931 <  fi
2932 <  rm -f conftest*
2933 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
2934 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
2935 <  echo 'void f(){}' > conftest.cc
2936 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
2937 <    echo "$as_me:$LINENO: result: yes" >&5
2938 < echo "${ECHO_T}yes" >&6
2939 <    OOPSE_TEMPLATE_FLAGS="-pto"
2940 <  else
2941 <    echo "$as_me:$LINENO: result: no" >&5
2942 < echo "${ECHO_T}no" >&6
2943 <  fi
2944 <  rm -f conftest*
2945 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
2946 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
2947 <  echo 'void f(){}' > conftest.cc
2948 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
2949 <    echo "$as_me:$LINENO: result: yes" >&5
2950 < echo "${ECHO_T}yes" >&6
2951 <
2952 <
2953 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
2954 <  else
2955 <    echo "$as_me:$LINENO: result: no" >&5
2956 < echo "${ECHO_T}no" >&6
2957 <  fi
2958 < fi
2959 <
2960 <
2961 <
2962 <
2963 < ac_ext=f90
2964 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
2965 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2966 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
2651 > ac_ext=${FC_SRCEXT-f}
2652 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2653 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2654 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2655   if test -n "$ac_tool_prefix"; then
2656 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2656 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2657    do
2658      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2659   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2660   echo "$as_me:$LINENO: checking for $ac_word" >&5
2661   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2662 < if test "${ac_cv_prog_F90+set}" = set; then
2662 > if test "${ac_cv_prog_FC+set}" = set; then
2663    echo $ECHO_N "(cached) $ECHO_C" >&6
2664   else
2665 <  if test -n "$F90"; then
2666 <  ac_cv_prog_F90="$F90" # Let the user override the test.
2665 >  if test -n "$FC"; then
2666 >  ac_cv_prog_FC="$FC" # Let the user override the test.
2667   else
2668   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2669   for as_dir in $PATH
# Line 2984 | Line 2672 | do
2672    test -z "$as_dir" && as_dir=.
2673    for ac_exec_ext in '' $ac_executable_extensions; do
2674    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2675 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
2675 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2676      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2677      break 2
2678    fi
# Line 2993 | Line 2681 | fi
2681  
2682   fi
2683   fi
2684 < F90=$ac_cv_prog_F90
2685 < if test -n "$F90"; then
2686 <  echo "$as_me:$LINENO: result: $F90" >&5
2687 < echo "${ECHO_T}$F90" >&6
2684 > FC=$ac_cv_prog_FC
2685 > if test -n "$FC"; then
2686 >  echo "$as_me:$LINENO: result: $FC" >&5
2687 > echo "${ECHO_T}$FC" >&6
2688   else
2689    echo "$as_me:$LINENO: result: no" >&5
2690   echo "${ECHO_T}no" >&6
2691   fi
2692  
2693 <    test -n "$F90" && break
2693 >    test -n "$FC" && break
2694    done
2695   fi
2696 < if test -z "$F90"; then
2697 <  ac_ct_F90=$F90
2698 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2696 > if test -z "$FC"; then
2697 >  ac_ct_FC=$FC
2698 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2699   do
2700    # Extract the first word of "$ac_prog", so it can be a program name with args.
2701   set dummy $ac_prog; ac_word=$2
2702   echo "$as_me:$LINENO: checking for $ac_word" >&5
2703   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2704 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
2704 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2705    echo $ECHO_N "(cached) $ECHO_C" >&6
2706   else
2707 <  if test -n "$ac_ct_F90"; then
2708 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
2707 >  if test -n "$ac_ct_FC"; then
2708 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2709   else
2710   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2711   for as_dir in $PATH
# Line 3026 | Line 2714 | do
2714    test -z "$as_dir" && as_dir=.
2715    for ac_exec_ext in '' $ac_executable_extensions; do
2716    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2717 <    ac_cv_prog_ac_ct_F90="$ac_prog"
2717 >    ac_cv_prog_ac_ct_FC="$ac_prog"
2718      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2719      break 2
2720    fi
# Line 3035 | Line 2723 | fi
2723  
2724   fi
2725   fi
2726 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
2727 < if test -n "$ac_ct_F90"; then
2728 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
2729 < echo "${ECHO_T}$ac_ct_F90" >&6
2726 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
2727 > if test -n "$ac_ct_FC"; then
2728 >  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2729 > echo "${ECHO_T}$ac_ct_FC" >&6
2730   else
2731    echo "$as_me:$LINENO: result: no" >&5
2732   echo "${ECHO_T}no" >&6
2733   fi
2734  
2735 <  test -n "$ac_ct_F90" && break
2735 >  test -n "$ac_ct_FC" && break
2736   done
2737  
2738 <  F90=$ac_ct_F90
2738 >  FC=$ac_ct_FC
2739   fi
2740  
2741  
2742 < # If we don't use `.F90' as extension, the preprocessor is not run on the
2743 < # input file.
2742 > # Provide some information about the compiler.
2743 > echo "$as_me:2743:" \
2744 >     "checking for Fortran compiler version" >&5
2745 > ac_compiler=`set X $ac_compile; echo $2`
2746 > { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2747 >  (eval $ac_compiler --version </dev/null >&5) 2>&5
2748 >  ac_status=$?
2749 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2750 >  (exit $ac_status); }
2751 > { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2752 >  (eval $ac_compiler -v </dev/null >&5) 2>&5
2753 >  ac_status=$?
2754 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2755 >  (exit $ac_status); }
2756 > { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2757 >  (eval $ac_compiler -V </dev/null >&5) 2>&5
2758 >  ac_status=$?
2759 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2760 >  (exit $ac_status); }
2761 > rm -f a.out
2762 >
2763 > # If we don't use `.F' as extension, the preprocessor is not run on the
2764 > # input file.  (Note that this only needs to work for GNU compilers.)
2765   ac_save_ext=$ac_ext
2766 < ac_ext=F90
2767 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
2768 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
2769 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
2766 > ac_ext=F
2767 > echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2768 > echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2769 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2770    echo $ECHO_N "(cached) $ECHO_C" >&6
2771   else
2772    cat >conftest.$ac_ext <<_ACEOF
2773 <
3065 < program main
3066 <
2773 >      program main
2774   #ifndef __GNUC__
2775         choke me
2776   #endif
2777  
2778 < end program main
3072 <
2778 >      end
2779   _ACEOF
2780   rm -f conftest.$ac_objext
2781   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2782 <  (eval $ac_compile) 2>&5
2782 >  (eval $ac_compile) 2>conftest.er1
2783    ac_status=$?
2784 +  grep -v '^ *+' conftest.er1 >conftest.err
2785 +  rm -f conftest.er1
2786 +  cat conftest.err >&5
2787    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2788    (exit $ac_status); } &&
2789 <         { ac_try='test -s conftest.$ac_objext'
2789 >         { ac_try='test -z "$ac_fc_werror_flag"
2790 >                         || test ! -s conftest.err'
2791    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2792    (eval $ac_try) 2>&5
2793    ac_status=$?
2794    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2795 +  (exit $ac_status); }; } &&
2796 +         { ac_try='test -s conftest.$ac_objext'
2797 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2798 +  (eval $ac_try) 2>&5
2799 +  ac_status=$?
2800 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2801    (exit $ac_status); }; }; then
2802    ac_compiler_gnu=yes
2803   else
# Line 3090 | Line 2806 | fi
2806  
2807   ac_compiler_gnu=no
2808   fi
2809 < rm -f conftest.$ac_objext conftest.$ac_ext
2810 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
2809 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2810 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2811  
2812   fi
2813 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
2814 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
2813 > echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2814 > echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2815   ac_ext=$ac_save_ext
2816 < G95=`test $ac_compiler_gnu = yes && echo yes`
2817 < ac_ext=c
2818 < ac_cpp='$CPP $CPPFLAGS'
2819 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2820 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2821 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
2816 > ac_test_FFLAGS=${FCFLAGS+set}
2817 > ac_save_FFLAGS=$FCFLAGS
2818 > FCFLAGS=
2819 > echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2820 > echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2821 > if test "${ac_cv_prog_fc_g+set}" = set; then
2822 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2823 > else
2824 >  FCFLAGS=-g
2825 > cat >conftest.$ac_ext <<_ACEOF
2826 >      program main
2827  
2828 <
3108 <
3109 <
3110 <
3111 < # Try to determine native compiler flags that allow us to use F90 suffix
3112 < # for preprocessed f90 source.
3113 <
3114 < if test "$ac_test_PREPFLAG" != "set"; then
3115 <  PREPFLAG=""
3116 <  case "${host_cpu}-${host_os}" in
3117 <
3118 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3119 <                    PREPFLAG="-fpp1 "
3120 <                fi;;
3121 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3122 <                    PREPFLAG="-qsuffix=cpp=F90 "
3123 <                fi;;
3124 <  *darwin*)
3125 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3126 <                PREPFLAG="-qsuffix=cpp=F90 "
3127 <        fi;;
3128 <  esac
3129 <
3130 <  if test -z "$PREPFLAG"; then
3131 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3132 < echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3133 <        PREPFLAG=""
3134 <  fi
3135 <
3136 <  echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3137 < echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3138 <
3139 <
3140 <  ac_ext=f90
3141 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3142 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3143 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3144 <
3145 <  ac_save_ext=$ac_ext
3146 <  ac_ext=F90
3147 <  ac_save_F90FLAGS=$F90FLAGS
3148 <
3149 <  if test "$PREPFLAG"; then
3150 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3151 < fi
3152 <
3153 <    cat >conftest.$ac_ext <<_ACEOF
3154 <
3155 <
3156 < program main
3157 <
3158 <  integer :: i
3159 <  i = 1
3160 <
3161 <
3162 < end program main
3163 <
2828 >      end
2829   _ACEOF
2830   rm -f conftest.$ac_objext
2831   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2832 <  (eval $ac_compile) 2>&5
2832 >  (eval $ac_compile) 2>conftest.er1
2833    ac_status=$?
2834 +  grep -v '^ *+' conftest.er1 >conftest.err
2835 +  rm -f conftest.er1
2836 +  cat conftest.err >&5
2837    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2838    (exit $ac_status); } &&
2839 <         { ac_try='test -s conftest.$ac_objext'
2839 >         { ac_try='test -z "$ac_fc_werror_flag"
2840 >                         || test ! -s conftest.err'
2841    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2842    (eval $ac_try) 2>&5
2843    ac_status=$?
2844    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2845 +  (exit $ac_status); }; } &&
2846 +         { ac_try='test -s conftest.$ac_objext'
2847 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2848 +  (eval $ac_try) 2>&5
2849 +  ac_status=$?
2850 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2851    (exit $ac_status); }; }; then
2852 <  prepflagworks=1
2852 >  ac_cv_prog_fc_g=yes
2853   else
2854    echo "$as_me: failed program was:" >&5
2855   sed 's/^/| /' conftest.$ac_ext >&5
2856  
2857 < prepflagworks=0
2857 > ac_cv_prog_fc_g=no
2858   fi
2859 < rm -f conftest.$ac_objext conftest.$ac_ext
2859 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2860  
2861 <  F90FLAGS=$ac_save_F90FLAGS
2862 <  ac_ext=$ac_save_ext
2863 <  ac_ext=c
2861 > fi
2862 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2863 > echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2864 > if test "$ac_test_FFLAGS" = set; then
2865 >  FCFLAGS=$ac_save_FFLAGS
2866 > elif test $ac_cv_prog_fc_g = yes; then
2867 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2868 >    FCFLAGS="-g -O2"
2869 >  else
2870 >    FCFLAGS="-g"
2871 >  fi
2872 > else
2873 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2874 >    FCFLAGS="-O2"
2875 >  else
2876 >    FCFLAGS=
2877 >  fi
2878 > fi
2879 >
2880 > ac_ext=c
2881   ac_cpp='$CPP $CPPFLAGS'
2882   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2883   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2884   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2885  
2886 + ac_ext=c
2887 + ac_cpp='$CPP $CPPFLAGS'
2888 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2889 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2890 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2891 + echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2892 + echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2893 + # On Suns, sometimes $CPP names a directory.
2894 + if test -n "$CPP" && test -d "$CPP"; then
2895 +  CPP=
2896 + fi
2897 + if test -z "$CPP"; then
2898 +  if test "${ac_cv_prog_CPP+set}" = set; then
2899 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2900 + else
2901 +      # Double quotes because CPP needs to be expanded
2902 +    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
2903 +    do
2904 +      ac_preproc_ok=false
2905 + for ac_c_preproc_warn_flag in '' yes
2906 + do
2907 +  # Use a header file that comes with gcc, so configuring glibc
2908 +  # with a fresh cross-compiler works.
2909 +  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2910 +  # <limits.h> exists even on freestanding compilers.
2911 +  # On the NeXT, cc -E runs the code through the compiler's parser,
2912 +  # not just through cpp. "Syntax error" is here to catch this case.
2913 +  cat >conftest.$ac_ext <<_ACEOF
2914 + /* confdefs.h.  */
2915 + _ACEOF
2916 + cat confdefs.h >>conftest.$ac_ext
2917 + cat >>conftest.$ac_ext <<_ACEOF
2918 + /* end confdefs.h.  */
2919 + #ifdef __STDC__
2920 + # include <limits.h>
2921 + #else
2922 + # include <assert.h>
2923 + #endif
2924 +                     Syntax error
2925 + _ACEOF
2926 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2927 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2928 +  ac_status=$?
2929 +  grep -v '^ *+' conftest.er1 >conftest.err
2930 +  rm -f conftest.er1
2931 +  cat conftest.err >&5
2932 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2933 +  (exit $ac_status); } >/dev/null; then
2934 +  if test -s conftest.err; then
2935 +    ac_cpp_err=$ac_c_preproc_warn_flag
2936 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
2937 +  else
2938 +    ac_cpp_err=
2939 +  fi
2940 + else
2941 +  ac_cpp_err=yes
2942 + fi
2943 + if test -z "$ac_cpp_err"; then
2944 +  :
2945 + else
2946 +  echo "$as_me: failed program was:" >&5
2947 + sed 's/^/| /' conftest.$ac_ext >&5
2948  
2949 <  if test "$prepflagworks" = 1; then
2950 <    echo "$as_me:$LINENO: result: yes" >&5
2951 < echo "${ECHO_T}yes" >&6
2949 >  # Broken: fails on valid input.
2950 > continue
2951 > fi
2952 > rm -f conftest.err conftest.$ac_ext
2953  
2954 +  # OK, works on sane cases.  Now check whether non-existent headers
2955 +  # can be detected and how.
2956 +  cat >conftest.$ac_ext <<_ACEOF
2957 + /* confdefs.h.  */
2958 + _ACEOF
2959 + cat confdefs.h >>conftest.$ac_ext
2960 + cat >>conftest.$ac_ext <<_ACEOF
2961 + /* end confdefs.h.  */
2962 + #include <ac_nonexistent.h>
2963 + _ACEOF
2964 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2965 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2966 +  ac_status=$?
2967 +  grep -v '^ *+' conftest.er1 >conftest.err
2968 +  rm -f conftest.er1
2969 +  cat conftest.err >&5
2970 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2971 +  (exit $ac_status); } >/dev/null; then
2972 +  if test -s conftest.err; then
2973 +    ac_cpp_err=$ac_c_preproc_warn_flag
2974 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
2975    else
2976 <    echo "$as_me:$LINENO: result: no" >&5
3201 < echo "${ECHO_T}no" >&6
3202 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3203 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3204 <   { (exit 1); exit 1; }; }
2976 >    ac_cpp_err=
2977    fi
2978 + else
2979 +  ac_cpp_err=yes
2980   fi
2981 + if test -z "$ac_cpp_err"; then
2982 +  # Broken: success on invalid input.
2983 + continue
2984 + else
2985 +  echo "$as_me: failed program was:" >&5
2986 + sed 's/^/| /' conftest.$ac_ext >&5
2987  
2988 +  # Passes both tests.
2989 + ac_preproc_ok=:
2990 + break
2991 + fi
2992 + rm -f conftest.err conftest.$ac_ext
2993  
2994 <
2995 <
2996 <
2997 < # Try to determine native compiler flags that allow us to use F90 suffix
2998 < # for preprocessed f90 source with -D type defines
3214 <
3215 < if test "$ac_test_PREPDEFFLAG" != "set"; then
3216 <  PREPDEFFLAG=""
3217 <  case "${host_cpu}-${host_os}" in
3218 <
3219 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3220 <                    PREPDEFFLAG=" "
3221 <                fi;;
3222 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3223 <                    PREPDEFFLAG="-WF,"
3224 <                fi;;
3225 <  *darwin*)
3226 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3227 <                PREPDEFFLAG="-WF,"
3228 <        fi;;
3229 <  esac
3230 <
3231 <  if test -z "$PREPDEFFLAG"; then
3232 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3233 < echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3234 <        PREPDEFFLAG=" "
3235 <  fi
3236 <
3237 <  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3238 < echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3239 <
3240 <
3241 <  ac_ext=f90
3242 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3243 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3244 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3245 <
3246 <  ac_save_ext=$ac_ext
3247 <  ac_ext=F90
3248 <  ac_save_F90FLAGS=$F90FLAGS
3249 <
3250 <  if test "$PREPDEFFLAG"; then
3251 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
2994 > done
2995 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
2996 > rm -f conftest.err conftest.$ac_ext
2997 > if $ac_preproc_ok; then
2998 >  break
2999   fi
3000  
3001 <    cat >conftest.$ac_ext <<_ACEOF
3001 >    done
3002 >    ac_cv_prog_CPP=$CPP
3003  
3004 <
3005 < program main
3006 <
3007 <  integer :: i
3008 < #ifdef TEST
3009 <  i = 1
3004 > fi
3005 >  CPP=$ac_cv_prog_CPP
3006 > else
3007 >  ac_cv_prog_CPP=$CPP
3008 > fi
3009 > echo "$as_me:$LINENO: result: $CPP" >&5
3010 > echo "${ECHO_T}$CPP" >&6
3011 > ac_preproc_ok=false
3012 > for ac_c_preproc_warn_flag in '' yes
3013 > do
3014 >  # Use a header file that comes with gcc, so configuring glibc
3015 >  # with a fresh cross-compiler works.
3016 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3017 >  # <limits.h> exists even on freestanding compilers.
3018 >  # On the NeXT, cc -E runs the code through the compiler's parser,
3019 >  # not just through cpp. "Syntax error" is here to catch this case.
3020 >  cat >conftest.$ac_ext <<_ACEOF
3021 > /* confdefs.h.  */
3022 > _ACEOF
3023 > cat confdefs.h >>conftest.$ac_ext
3024 > cat >>conftest.$ac_ext <<_ACEOF
3025 > /* end confdefs.h.  */
3026 > #ifdef __STDC__
3027 > # include <limits.h>
3028   #else
3029 <  choke me
3029 > # include <assert.h>
3030   #endif
3031 +                     Syntax error
3032 + _ACEOF
3033 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3034 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3035 +  ac_status=$?
3036 +  grep -v '^ *+' conftest.er1 >conftest.err
3037 +  rm -f conftest.er1
3038 +  cat conftest.err >&5
3039 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3040 +  (exit $ac_status); } >/dev/null; then
3041 +  if test -s conftest.err; then
3042 +    ac_cpp_err=$ac_c_preproc_warn_flag
3043 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3044 +  else
3045 +    ac_cpp_err=
3046 +  fi
3047 + else
3048 +  ac_cpp_err=yes
3049 + fi
3050 + if test -z "$ac_cpp_err"; then
3051 +  :
3052 + else
3053 +  echo "$as_me: failed program was:" >&5
3054 + sed 's/^/| /' conftest.$ac_ext >&5
3055  
3056 +  # Broken: fails on valid input.
3057 + continue
3058 + fi
3059 + rm -f conftest.err conftest.$ac_ext
3060  
3061 < end program main
3062 <
3061 >  # OK, works on sane cases.  Now check whether non-existent headers
3062 >  # can be detected and how.
3063 >  cat >conftest.$ac_ext <<_ACEOF
3064 > /* confdefs.h.  */
3065   _ACEOF
3066 < rm -f conftest.$ac_objext
3067 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3068 <  (eval $ac_compile) 2>&5
3066 > cat confdefs.h >>conftest.$ac_ext
3067 > cat >>conftest.$ac_ext <<_ACEOF
3068 > /* end confdefs.h.  */
3069 > #include <ac_nonexistent.h>
3070 > _ACEOF
3071 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3072 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3073    ac_status=$?
3074 +  grep -v '^ *+' conftest.er1 >conftest.err
3075 +  rm -f conftest.er1
3076 +  cat conftest.err >&5
3077    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3078 <  (exit $ac_status); } &&
3079 <         { ac_try='test -s conftest.$ac_objext'
3080 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3081 <  (eval $ac_try) 2>&5
3082 <  ac_status=$?
3083 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3084 <  (exit $ac_status); }; }; then
3282 <  prepdefflagworks=1
3078 >  (exit $ac_status); } >/dev/null; then
3079 >  if test -s conftest.err; then
3080 >    ac_cpp_err=$ac_c_preproc_warn_flag
3081 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3082 >  else
3083 >    ac_cpp_err=
3084 >  fi
3085   else
3086 +  ac_cpp_err=yes
3087 + fi
3088 + if test -z "$ac_cpp_err"; then
3089 +  # Broken: success on invalid input.
3090 + continue
3091 + else
3092    echo "$as_me: failed program was:" >&5
3093   sed 's/^/| /' conftest.$ac_ext >&5
3094  
3095 < prepdefflagworks=0
3095 >  # Passes both tests.
3096 > ac_preproc_ok=:
3097 > break
3098   fi
3099 < rm -f conftest.$ac_objext conftest.$ac_ext
3099 > rm -f conftest.err conftest.$ac_ext
3100  
3101 <  F90FLAGS=$ac_save_F90FLAGS
3102 <  ac_ext=$ac_save_ext
3103 <  ac_ext=c
3101 > done
3102 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3103 > rm -f conftest.err conftest.$ac_ext
3104 > if $ac_preproc_ok; then
3105 >  :
3106 > else
3107 >  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3108 > See \`config.log' for more details." >&5
3109 > echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3110 > See \`config.log' for more details." >&2;}
3111 >   { (exit 1); exit 1; }; }
3112 > fi
3113 >
3114 > ac_ext=c
3115   ac_cpp='$CPP $CPPFLAGS'
3116   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3117   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3118   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3119  
3120 + echo "$as_me:$LINENO: checking for egrep" >&5
3121 + echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3122 + if test "${ac_cv_prog_egrep+set}" = set; then
3123 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3124 + else
3125 +  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3126 +    then ac_cv_prog_egrep='grep -E'
3127 +    else ac_cv_prog_egrep='egrep'
3128 +    fi
3129 + fi
3130 + echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3131 + echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3132 + EGREP=$ac_cv_prog_egrep
3133  
3134  
3135 <  if test "$prepdefflagworks" = 1; then
3136 <    echo "$as_me:$LINENO: result: yes" >&5
3135 > echo "$as_me:$LINENO: checking whether ln -s works" >&5
3136 > echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3137 > LN_S=$as_ln_s
3138 > if test "$LN_S" = "ln -s"; then
3139 >  echo "$as_me:$LINENO: result: yes" >&5
3140   echo "${ECHO_T}yes" >&6
3141 <
3142 <  else
3143 <    echo "$as_me:$LINENO: result: no" >&5
3307 < echo "${ECHO_T}no" >&6
3308 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
3309 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3310 <   { (exit 1); exit 1; }; }
3311 <  fi
3141 > else
3142 >  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3143 > echo "${ECHO_T}no, using $LN_S" >&6
3144   fi
3145  
3146 < ac_ext=f90
3147 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3148 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3149 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3318 <
3319 <
3320 <
3321 < ac_ext=f90
3322 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3323 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3324 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3325 < echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3326 < echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3327 < if test "${ac_cv_prog_f90_v+set}" = set; then
3146 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3147 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3148 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3149 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3150    echo $ECHO_N "(cached) $ECHO_C" >&6
3151   else
3152 +  cat >conftest.make <<\_ACEOF
3153 + all:
3154 +        @echo 'ac_maketemp="$(MAKE)"'
3155 + _ACEOF
3156 + # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3157 + eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3158 + if test -n "$ac_maketemp"; then
3159 +  eval ac_cv_prog_make_${ac_make}_set=yes
3160 + else
3161 +  eval ac_cv_prog_make_${ac_make}_set=no
3162 + fi
3163 + rm -f conftest.make
3164 + fi
3165 + if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3166 +  echo "$as_me:$LINENO: result: yes" >&5
3167 + echo "${ECHO_T}yes" >&6
3168 +  SET_MAKE=
3169 + else
3170 +  echo "$as_me:$LINENO: result: no" >&5
3171 + echo "${ECHO_T}no" >&6
3172 +  SET_MAKE="MAKE=${MAKE-make}"
3173 + fi
3174  
3175 < cat >conftest.$ac_ext <<_ACEOF
3175 > if test -n "$ac_tool_prefix"; then
3176 >  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3177 > set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3178 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3179 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3180 > if test "${ac_cv_prog_RANLIB+set}" = set; then
3181 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3182 > else
3183 >  if test -n "$RANLIB"; then
3184 >  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3185 > else
3186 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3187 > for as_dir in $PATH
3188 > do
3189 >  IFS=$as_save_IFS
3190 >  test -z "$as_dir" && as_dir=.
3191 >  for ac_exec_ext in '' $ac_executable_extensions; do
3192 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3193 >    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3194 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3195 >    break 2
3196 >  fi
3197 > done
3198 > done
3199  
3200 < program main
3200 > fi
3201 > fi
3202 > RANLIB=$ac_cv_prog_RANLIB
3203 > if test -n "$RANLIB"; then
3204 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3205 > echo "${ECHO_T}$RANLIB" >&6
3206 > else
3207 >  echo "$as_me:$LINENO: result: no" >&5
3208 > echo "${ECHO_T}no" >&6
3209 > fi
3210  
3211 + fi
3212 + if test -z "$ac_cv_prog_RANLIB"; then
3213 +  ac_ct_RANLIB=$RANLIB
3214 +  # Extract the first word of "ranlib", so it can be a program name with args.
3215 + set dummy ranlib; ac_word=$2
3216 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3217 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3218 + if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3219 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3220 + else
3221 +  if test -n "$ac_ct_RANLIB"; then
3222 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3223 + else
3224 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3225 + for as_dir in $PATH
3226 + do
3227 +  IFS=$as_save_IFS
3228 +  test -z "$as_dir" && as_dir=.
3229 +  for ac_exec_ext in '' $ac_executable_extensions; do
3230 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3231 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3232 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3233 +    break 2
3234 +  fi
3235 + done
3236 + done
3237  
3238 < end program main
3238 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3239 > fi
3240 > fi
3241 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3242 > if test -n "$ac_ct_RANLIB"; then
3243 >  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3244 > echo "${ECHO_T}$ac_ct_RANLIB" >&6
3245 > else
3246 >  echo "$as_me:$LINENO: result: no" >&5
3247 > echo "${ECHO_T}no" >&6
3248 > fi
3249  
3250 < _ACEOF
3251 < rm -f conftest.$ac_objext
3252 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3253 <  (eval $ac_compile) 2>&5
3342 <  ac_status=$?
3343 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3344 <  (exit $ac_status); } &&
3345 <         { ac_try='test -s conftest.$ac_objext'
3346 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3347 <  (eval $ac_try) 2>&5
3348 <  ac_status=$?
3349 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3350 <  (exit $ac_status); }; }; then
3351 <  ac_cv_prog_f90_v=
3352 < # Try some options frequently used verbose output
3353 < for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3354 <  ac_ext=f90
3355 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3356 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3357 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3250 >  RANLIB=$ac_ct_RANLIB
3251 > else
3252 >  RANLIB="$ac_cv_prog_RANLIB"
3253 > fi
3254  
3359 cat >conftest.$ac_ext <<_ACEOF
3255  
3256 < program main
3256 >   # Extract the first word of "perl", so it can be a program name with args.
3257 > set dummy perl; ac_word=$2
3258 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3259 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3260 > if test "${ac_cv_path_PERLINTERP+set}" = set; then
3261 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3262 > else
3263 >  case $PERLINTERP in
3264 >  [\\/]* | ?:[\\/]*)
3265 >  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3266 >  ;;
3267 >  *)
3268 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3269 > for as_dir in $PATH
3270 > do
3271 >  IFS=$as_save_IFS
3272 >  test -z "$as_dir" && as_dir=.
3273 >  for ac_exec_ext in '' $ac_executable_extensions; do
3274 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3275 >    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3276 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3277 >    break 2
3278 >  fi
3279 > done
3280 > done
3281  
3282 +  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3283 +  ;;
3284 + esac
3285 + fi
3286 + PERLINTERP=$ac_cv_path_PERLINTERP
3287  
3288 < end program main
3288 > if test -n "$PERLINTERP"; then
3289 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3290 > echo "${ECHO_T}$PERLINTERP" >&6
3291 > else
3292 >  echo "$as_me:$LINENO: result: no" >&5
3293 > echo "${ECHO_T}no" >&6
3294 > fi
3295  
3296 < _ACEOF
3296 >   ac_cv_path_perlinterp="$PERLINTERP"
3297 >   _sHpB='#!'
3298  
3368 # Compile and link our simple test program by passing a flag (argument
3369 # 1 to this macro) to the Fortran 90 compiler in order to get
3370 # "verbose" output that we can then parse for the Fortran 90 linker
3371 # flags.
3372 ac_save_F90FLAGS=$F90FLAGS
3373 F90FLAGS="$F90FLAGS $ac_verb"
3299  
3300 < (eval echo $as_me:3375: \"$ac_link\") >&5
3301 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3302 < echo "$ac_f90_v_output" >&5
3303 < F90FLAGS=$ac_save_F90FLAGS
3300 > # Check whether --with-perl-shebang or --without-perl-shebang was given.
3301 > if test "${with_perl_shebang+set}" = set; then
3302 >  withval="$with_perl_shebang"
3303 >  opt_perl_shebang="$withval"
3304 > else
3305 >                opt_perl_shebang="not_set"
3306 > fi;
3307 >   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3308 > echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3309 > if test "${ax_cv_opt_perl_shebang+set}" = set; then
3310 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3311 > else
3312 >   case "$opt_perl_shebang" in
3313 >                      not_set  ) ax_cv_opt_perl_shebang=''
3314 >                               ;;
3315 >                         *     )
3316 >        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3317 >                    esac
3318  
3319 < rm -f conftest.*
3320 < ac_ext=f90
3321 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3322 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3323 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3319 > fi
3320 > echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3321 > echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3322 >   if test "A$ax_cv_opt_perl_shebang" != "A"
3323 >     then
3324 >       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3325 >       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3326 >              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3327 > echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3328  
3329 < # If we are using xlf then replace all the commas with spaces.
3330 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3331 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3329 > # Automatic detection of sharpbang formula starts here
3330 >     else
3331 >   _somian_shbangperl=`$PERLINTERP -V:startperl`
3332 >   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3333 >   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3334 > echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3335 > if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3336 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3337 > else
3338 >  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3339 >        if test "x$_somian_kspb_perl" == x
3340 >          then _somian_ksbp_warn_empty='durnit'
3341 >          else
3342 >          case "A$_somian_kspb_perl" in
3343 >                 A#!*perl* )
3344 >           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3345 >                        ;;
3346 >                     A*    )  _somian_ksbp_warn_defau='trouble'
3347 >                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3348 >          esac
3349 >        fi
3350 >
3351 > fi
3352 > echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3353 > echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3354 > # The above prints Checking ... result message to user.
3355 >   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3356 >
3357 >    if test A${_somian_ksbp_warn_empty+set} == Aset
3358 >      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3359 > echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3360 >    fi
3361 > # Inform user after printing result value
3362 >    if test A${_somian_ksbp_warn_defau+set} == Aset
3363 >      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3364 > echo "$as_me: Maybe Not good -" >&6;}
3365 >           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3366 > echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3367 >      else { echo "$as_me:$LINENO: OK Good result - " >&5
3368 > echo "$as_me: OK Good result - " >&6;}
3369 >           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3370 > echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3371 >    fi
3372 >  fi
3373 >
3374 > # Find a good install program.  We prefer a C program (faster),
3375 > # so one script is as good as another.  But avoid the broken or
3376 > # incompatible versions:
3377 > # SysV /etc/install, /usr/sbin/install
3378 > # SunOS /usr/etc/install
3379 > # IRIX /sbin/install
3380 > # AIX /bin/install
3381 > # AmigaOS /C/install, which installs bootblocks on floppy discs
3382 > # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3383 > # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3384 > # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3385 > # OS/2's system install, which has a completely different semantic
3386 > # ./install, which can be erroneously created by make from ./install.sh.
3387 > echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3388 > echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3389 > if test -z "$INSTALL"; then
3390 > if test "${ac_cv_path_install+set}" = set; then
3391 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3392 > else
3393 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3394 > for as_dir in $PATH
3395 > do
3396 >  IFS=$as_save_IFS
3397 >  test -z "$as_dir" && as_dir=.
3398 >  # Account for people who put trailing slashes in PATH elements.
3399 > case $as_dir/ in
3400 >  ./ | .// | /cC/* | \
3401 >  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3402 >  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3403 >  /usr/ucb/* ) ;;
3404 >  *)
3405 >    # OSF1 and SCO ODT 3.0 have their own names for install.
3406 >    # Don't use installbsd from OSF since it installs stuff as root
3407 >    # by default.
3408 >    for ac_prog in ginstall scoinst install; do
3409 >      for ac_exec_ext in '' $ac_executable_extensions; do
3410 >        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3411 >          if test $ac_prog = install &&
3412 >            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3413 >            # AIX install.  It has an incompatible calling convention.
3414 >            :
3415 >          elif test $ac_prog = install &&
3416 >            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3417 >            # program-specific install script used by HP pwplus--don't use.
3418 >            :
3419 >          else
3420 >            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3421 >            break 3
3422 >          fi
3423 >        fi
3424 >      done
3425 >    done
3426 >    ;;
3427 > esac
3428 > done
3429 >
3430 >
3431 > fi
3432 >  if test "${ac_cv_path_install+set}" = set; then
3433 >    INSTALL=$ac_cv_path_install
3434 >  else
3435 >    # As a last resort, use the slow shell script.  We don't cache a
3436 >    # path for INSTALL within a source directory, because that will
3437 >    # break other packages using the cache if that directory is
3438 >    # removed, or if the path is relative.
3439 >    INSTALL=$ac_install_sh
3440 >  fi
3441 > fi
3442 > echo "$as_me:$LINENO: result: $INSTALL" >&5
3443 > echo "${ECHO_T}$INSTALL" >&6
3444 >
3445 > # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3446 > # It thinks the first close brace ends the variable substitution.
3447 > test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3448 >
3449 > test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3450 >
3451 > test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3452 >
3453 > case "x$INSTALL" in
3454 >   x/*) ;;
3455 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3456 > esac
3457 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3458 > # Extract the first word of "ar", so it can be a program name with args.
3459 > set dummy ar; ac_word=$2
3460 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3461 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3462 > if test "${ac_cv_prog_AR+set}" = set; then
3463 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3464 > else
3465 >  if test -n "$AR"; then
3466 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3467 > else
3468 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3469 > for as_dir in $PATH
3470 > do
3471 >  IFS=$as_save_IFS
3472 >  test -z "$as_dir" && as_dir=.
3473 >  for ac_exec_ext in '' $ac_executable_extensions; do
3474 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3475 >    ac_cv_prog_AR="ar"
3476 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3477 >    break 2
3478 >  fi
3479 > done
3480 > done
3481 >
3482 >  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3483 > fi
3484 > fi
3485 > AR=$ac_cv_prog_AR
3486 > if test -n "$AR"; then
3487 >  echo "$as_me:$LINENO: result: $AR" >&5
3488 > echo "${ECHO_T}$AR" >&6
3489 > else
3490 >  echo "$as_me:$LINENO: result: no" >&5
3491 > echo "${ECHO_T}no" >&6
3492 > fi
3493 >
3494 > if test "$AR" = "NONE"; then
3495 >  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
3496 > echo "$as_me: error: --> Can't find \`ar'!" >&2;}
3497 >   { (exit 1); exit 1; }; }
3498 >  cat >confcache <<\_ACEOF
3499 > # This file is a shell script that caches the results of configure
3500 > # tests run on this system so they can be shared between configure
3501 > # scripts and configure runs, see configure's option --config-cache.
3502 > # It is not useful on other systems.  If it contains results you don't
3503 > # want to keep, you may remove or edit it.
3504 > #
3505 > # config.status only pays attention to the cache file if you give it
3506 > # the --recheck option to rerun configure.
3507 > #
3508 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3509 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3510 > # following values.
3511 >
3512 > _ACEOF
3513 >
3514 > # The following way of writing the cache mishandles newlines in values,
3515 > # but we know of no workaround that is simple, portable, and efficient.
3516 > # So, don't put newlines in cache variables' values.
3517 > # Ultrix sh set writes to stderr and can't be redirected directly,
3518 > # and sets the high bit in the cache file unless we assign to the vars.
3519 > {
3520 >  (set) 2>&1 |
3521 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3522 >    *ac_space=\ *)
3523 >      # `set' does not quote correctly, so add quotes (double-quote
3524 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3525 >      sed -n \
3526 >        "s/'/'\\\\''/g;
3527 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3528 >      ;;
3529 >    *)
3530 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3531 >      sed -n \
3532 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3533 >      ;;
3534 >    esac;
3535 > } |
3536 >  sed '
3537 >     t clear
3538 >     : clear
3539 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3540 >     t end
3541 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3542 >     : end' >>confcache
3543 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3544 >  if test -w $cache_file; then
3545 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3546 >    cat confcache >$cache_file
3547 >  else
3548 >    echo "not updating unwritable cache $cache_file"
3549 >  fi
3550 > fi
3551 > rm -f confcache
3552 >  exit 1
3553 > fi
3554 > # Extract the first word of "ps", so it can be a program name with args.
3555 > set dummy ps; ac_word=$2
3556 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3557 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3558 > if test "${ac_cv_path_PS+set}" = set; then
3559 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3560 > else
3561 >  case $PS in
3562 >  [\\/]* | ?:[\\/]*)
3563 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3564 >  ;;
3565 >  *)
3566 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3567 > for as_dir in $PATH
3568 > do
3569 >  IFS=$as_save_IFS
3570 >  test -z "$as_dir" && as_dir=.
3571 >  for ac_exec_ext in '' $ac_executable_extensions; do
3572 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3573 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3574 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3575 >    break 2
3576 >  fi
3577 > done
3578 > done
3579 >
3580 >  ;;
3581 > esac
3582 > fi
3583 > PS=$ac_cv_path_PS
3584 >
3585 > if test -n "$PS"; then
3586 >  echo "$as_me:$LINENO: result: $PS" >&5
3587 > echo "${ECHO_T}$PS" >&6
3588 > else
3589 >  echo "$as_me:$LINENO: result: no" >&5
3590 > echo "${ECHO_T}no" >&6
3591 > fi
3592 >
3593 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3594 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3595 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3596 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3597 > else
3598 >
3599 >        if $PS ax -o rss > /dev/null 2>&1; then
3600 >                ac_cv_prog_ps_ax=yes
3601 >        else
3602 >                ac_cv_prog_ps_ax=no
3603 >        fi
3604 >        if $PS -ef -o rss > /dev/null 2>&1; then
3605 >                ac_cv_prog_ps_ef=yes
3606 >        else
3607 >                ac_cv_prog_ps_ef=no
3608 >        fi
3609 >        if test "$ac_cv_prog_ps_ax" = yes; then
3610 >                ac_cv_prog_ps_syntax=BSD
3611 >        else
3612 >                if test "$ac_cv_prog_ps_ef" = yes; then
3613 >                        ac_cv_prog_ps_syntax=POSIX
3614 >                else
3615 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3616 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3617 >   { (exit 1); exit 1; }; }
3618 >                fi
3619 >        fi
3620 >
3621 > fi
3622 > echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3623 > echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3624 >
3625 > cat >>confdefs.h <<_ACEOF
3626 > #define PSCOMMAND $PS
3627 > _ACEOF
3628 >
3629 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3630 >
3631 > cat >>confdefs.h <<\_ACEOF
3632 > #define PSTYPE_IS_BSD 1
3633 > _ACEOF
3634 >
3635 > else
3636 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3637 >
3638 > cat >>confdefs.h <<\_ACEOF
3639 > #define PSTYPE_IS_POSIX 1
3640 > _ACEOF
3641 >
3642 >   else
3643 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3644 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3645 >   { (exit 1); exit 1; }; }
3646 >   fi
3647   fi
3648  
3649 < # If we are using Cray Fortran then delete quotes.
3650 < # Use "\"" instead of '"' for font-lock-mode.
3651 < # FIXME: a more general fix for quoted arguments with spaces?
3652 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3653 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3649 > ac_ext=${FC_SRCEXT-f}
3650 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3651 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3652 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3653 >
3654 >
3655 > echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3656 > echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3657 > if test "${ac_cv_fc_srcext_F90+set}" = set; then
3658 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3659 > else
3660 >  ac_ext=F90
3661 > ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3662 > FCFLAGS_SRCEXT=""
3663 > ac_cv_fc_srcext_F90=unknown
3664 > for ac_flag in none -qsuffix=f=F90 -Tf; do
3665 >  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3666 >  cat >conftest.$ac_ext <<_ACEOF
3667 >      program main
3668 >
3669 >      end
3670 > _ACEOF
3671 > rm -f conftest.$ac_objext
3672 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3673 >  (eval $ac_compile) 2>conftest.er1
3674 >  ac_status=$?
3675 >  grep -v '^ *+' conftest.er1 >conftest.err
3676 >  rm -f conftest.er1
3677 >  cat conftest.err >&5
3678 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3679 >  (exit $ac_status); } &&
3680 >         { ac_try='test -z "$ac_fc_werror_flag"
3681 >                         || test ! -s conftest.err'
3682 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3683 >  (eval $ac_try) 2>&5
3684 >  ac_status=$?
3685 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3686 >  (exit $ac_status); }; } &&
3687 >         { ac_try='test -s conftest.$ac_objext'
3688 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3689 >  (eval $ac_try) 2>&5
3690 >  ac_status=$?
3691 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3692 >  (exit $ac_status); }; }; then
3693 >  ac_cv_fc_srcext_F90=$ac_flag; break
3694 > else
3695 >  echo "$as_me: failed program was:" >&5
3696 > sed 's/^/| /' conftest.$ac_ext >&5
3697 >
3698 > fi
3699 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3700 > done
3701 > rm -f conftest.$ac_objext conftest.F90
3702 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3703 >
3704 > fi
3705 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3706 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3707 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3708 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3709 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3710 >   { (exit 1); exit 1; }; }
3711 > else
3712 >  FC_SRCEXT=F90
3713 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3714 >    FCFLAGS_SRCEXT=""
3715 >    FCFLAGS_F90=""
3716 >  else
3717 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3718 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3719 >  fi
3720 >
3721 >
3722 > fi
3723 >
3724 >
3725 >
3726 >
3727 >
3728 > # Try to determine native compiler flags that allow us to use F90 suffix
3729 > # for preprocessed f90 source.
3730 >
3731 > if test "$ac_test_PREPFLAG" != "set"; then
3732 >  PREPFLAG=""
3733 >  case "${host_cpu}-${host_os}" in
3734 >
3735 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3736 >                    PREPFLAG="-fpp1 "
3737 >                fi;;
3738 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3739 >                    PREPFLAG="-qsuffix=cpp=F90 "
3740 >                fi;;
3741 >  *darwin*)
3742 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3743 >                PREPFLAG="-qsuffix=cpp=F90 "
3744 >        fi;;
3745 >  esac
3746 >
3747 >  if test -z "$PREPFLAG"; then
3748 >        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3749 > echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3750 >        PREPFLAG=""
3751 >  fi
3752 >
3753 >  echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3754 > echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3755 >
3756 >
3757 >  ac_ext=${FC_SRCEXT-f}
3758 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3759 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3760 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3761 >
3762 >  ac_save_ext=$ac_ext
3763 >  ac_ext=F90
3764 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3765 >
3766 >  if test "$PREPFLAG"; then
3767 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3768 > fi
3769 >
3770 >    cat >conftest.$ac_ext <<_ACEOF
3771 >
3772 >
3773 > program conftest
3774 >  integer :: i
3775 >  i = 1
3776 > end program conftest
3777 >
3778 > _ACEOF
3779 > rm -f conftest.$ac_objext
3780 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3781 >  (eval $ac_compile) 2>conftest.er1
3782 >  ac_status=$?
3783 >  grep -v '^ *+' conftest.er1 >conftest.err
3784 >  rm -f conftest.er1
3785 >  cat conftest.err >&5
3786 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3787 >  (exit $ac_status); } &&
3788 >         { ac_try='test -z "$ac_fc_werror_flag"
3789 >                         || test ! -s conftest.err'
3790 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3791 >  (eval $ac_try) 2>&5
3792 >  ac_status=$?
3793 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3794 >  (exit $ac_status); }; } &&
3795 >         { ac_try='test -s conftest.$ac_objext'
3796 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3797 >  (eval $ac_try) 2>&5
3798 >  ac_status=$?
3799 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3800 >  (exit $ac_status); }; }; then
3801 >  prepflagworks=1
3802 > else
3803 >  echo "$as_me: failed program was:" >&5
3804 > sed 's/^/| /' conftest.$ac_ext >&5
3805 >
3806 > prepflagworks=0
3807 > fi
3808 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3809 >
3810 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3811 >  ac_ext=$ac_save_ext
3812 >  ac_ext=${FC_SRCEXT-f}
3813 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3814 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3815 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3816 >
3817 >
3818 >  if test "$prepflagworks" = 1; then
3819 >    echo "$as_me:$LINENO: result: yes" >&5
3820 > echo "${ECHO_T}yes" >&6
3821 >    FCFLAGS_SRCEXT="${PREPFLAG}"
3822 >
3823 >  else
3824 >    echo "$as_me:$LINENO: result: no" >&5
3825 > echo "${ECHO_T}no" >&6
3826 >    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3827 > echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3828 >   { (exit 1); exit 1; }; }
3829 >  fi
3830 > fi
3831 >
3832 >
3833 >
3834 >
3835 >
3836 > # Try to determine native compiler flags that allow us to use F90 suffix
3837 > # for preprocessed f90 source with -D type defines
3838 >
3839 > if test "$ac_test_PREPDEFFLAG" != "set"; then
3840 >  PREPDEFFLAG=""
3841 >  case "${host_cpu}-${host_os}" in
3842 >
3843 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3844 >                    PREPDEFFLAG=" "
3845 >                fi;;
3846 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3847 >                    PREPDEFFLAG="-WF,"
3848 >                fi;;
3849 >  *darwin*)
3850 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3851 >                PREPDEFFLAG="-WF,"
3852 >        fi;;
3853 >  esac
3854 >
3855 >  if test -z "$PREPDEFFLAG"; then
3856 >        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3857 > echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3858 >        PREPDEFFLAG=" "
3859 >  fi
3860 >
3861 >  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3862 > echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3863 >
3864 >
3865 >  ac_ext=${FC_SRCEXT-f}
3866 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3867 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3868 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3869 >
3870 >  ac_save_ext=$ac_ext
3871 >  ac_ext=F90
3872 >  ac_save_FCFLAGS=$FCFLAGS
3873 >
3874 >  if test "$PREPDEFFLAG"; then
3875 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3876 > fi
3877 >
3878 >    cat >conftest.$ac_ext <<_ACEOF
3879 >
3880 >
3881 > program conftest
3882 >  integer :: i
3883 > #ifdef TEST
3884 >  i = 1
3885 > #else
3886 >  choke me
3887 > #endif
3888 > end program conftest
3889 >
3890 > _ACEOF
3891 > rm -f conftest.$ac_objext
3892 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3893 >  (eval $ac_compile) 2>conftest.er1
3894 >  ac_status=$?
3895 >  grep -v '^ *+' conftest.er1 >conftest.err
3896 >  rm -f conftest.er1
3897 >  cat conftest.err >&5
3898 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3899 >  (exit $ac_status); } &&
3900 >         { ac_try='test -z "$ac_fc_werror_flag"
3901 >                         || test ! -s conftest.err'
3902 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3903 >  (eval $ac_try) 2>&5
3904 >  ac_status=$?
3905 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3906 >  (exit $ac_status); }; } &&
3907 >         { ac_try='test -s conftest.$ac_objext'
3908 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3909 >  (eval $ac_try) 2>&5
3910 >  ac_status=$?
3911 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3912 >  (exit $ac_status); }; }; then
3913 >  prepdefflagworks=1
3914 > else
3915 >  echo "$as_me: failed program was:" >&5
3916 > sed 's/^/| /' conftest.$ac_ext >&5
3917 >
3918 > prepdefflagworks=0
3919   fi
3920 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3921 +
3922 +  FCFLAGS=$ac_save_FCFLAGS
3923 +  ac_ext=$ac_save_ext
3924 +  ac_ext=${FC_SRCEXT-f}
3925 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3926 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3927 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3928 +
3929 +
3930 +  if test "$prepdefflagworks" = 1; then
3931 +    echo "$as_me:$LINENO: result: yes" >&5
3932 + echo "${ECHO_T}yes" >&6
3933 +
3934 +  else
3935 +    echo "$as_me:$LINENO: result: no" >&5
3936 + echo "${ECHO_T}no" >&6
3937 +    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
3938 + echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3939 +   { (exit 1); exit 1; }; }
3940 +  fi
3941 + fi
3942 +
3943 + ac_ext=${FC_SRCEXT-f}
3944 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3945 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3946 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3947 + echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
3948 + echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
3949 + if test "${ac_cv_prog_fc_v+set}" = set; then
3950 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3951 + else
3952 +  cat >conftest.$ac_ext <<_ACEOF
3953 +      program main
3954 +
3955 +      end
3956 + _ACEOF
3957 + rm -f conftest.$ac_objext
3958 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3959 +  (eval $ac_compile) 2>conftest.er1
3960 +  ac_status=$?
3961 +  grep -v '^ *+' conftest.er1 >conftest.err
3962 +  rm -f conftest.er1
3963 +  cat conftest.err >&5
3964 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3965 +  (exit $ac_status); } &&
3966 +         { ac_try='test -z "$ac_fc_werror_flag"
3967 +                         || test ! -s conftest.err'
3968 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3969 +  (eval $ac_try) 2>&5
3970 +  ac_status=$?
3971 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3972 +  (exit $ac_status); }; } &&
3973 +         { ac_try='test -s conftest.$ac_objext'
3974 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3975 +  (eval $ac_try) 2>&5
3976 +  ac_status=$?
3977 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3978 +  (exit $ac_status); }; }; then
3979 +  ac_cv_prog_fc_v=
3980 + # Try some options frequently used verbose output
3981 + for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3982 +  cat >conftest.$ac_ext <<_ACEOF
3983 +      program main
3984 +
3985 +      end
3986 + _ACEOF
3987 +
3988 + # Compile and link our simple test program by passing a flag (argument
3989 + # 1 to this macro) to the Fortran compiler in order to get
3990 + # "verbose" output that we can then parse for the Fortran linker
3991 + # flags.
3992 + ac_save_FFLAGS=$FCFLAGS
3993 + FCFLAGS="$FCFLAGS $ac_verb"
3994 + (eval echo $as_me:3994: \"$ac_link\") >&5
3995 + ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3996 + echo "$ac_fc_v_output" >&5
3997 + FCFLAGS=$ac_save_FFLAGS
3998 +
3999 + rm -f conftest*
4000 +
4001 + # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4002 + # /foo, /bar, and /baz are search directories for the Fortran linker.
4003 + # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4004 + ac_fc_v_output="`echo $ac_fc_v_output |
4005 +        grep 'LPATH is:' |
4006 +        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4007 +
4008 + case $ac_fc_v_output in
4009 +  # If we are using xlf then replace all the commas with spaces.
4010 +  *xlfentry*)
4011 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4012 +
4013 +  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4014 +  # $LIBS confuse us, and the libraries appear later in the output anyway).
4015 +  *mGLOB_options_string*)
4016 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4017 +
4018 +  # If we are using Cray Fortran then delete quotes.
4019 +  # Use "\"" instead of '"' for font-lock-mode.
4020 +  # FIXME: a more general fix for quoted arguments with spaces?
4021 +  *cft90*)
4022 +    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4023 + esac
4024 +
4025 +
4026    # look for -l* and *.a constructs in the output
4027 <  for ac_arg in $ac_f90_v_output; do
4027 >  for ac_arg in $ac_fc_v_output; do
4028       case $ac_arg in
4029          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4030 <          ac_cv_prog_f90_v=$ac_verb
4030 >          ac_cv_prog_fc_v=$ac_verb
4031            break 2 ;;
4032       esac
4033    done
4034   done
4035 < if test -z "$ac_cv_prog_f90_v"; then
4036 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4037 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4035 > if test -z "$ac_cv_prog_fc_v"; then
4036 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4037 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4038   fi
4039   else
4040    echo "$as_me: failed program was:" >&5
# Line 3414 | Line 4043 | fi
4043   { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4044   echo "$as_me: WARNING: compilation failed" >&2;}
4045   fi
4046 < rm -f conftest.$ac_objext conftest.$ac_ext
4046 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4047  
4048   fi
4049 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4050 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4051 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4052 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4053 < if test "${ac_cv_flibs+set}" = set; then
4049 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4050 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4051 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4052 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4053 > if test "${ac_cv_fc_libs+set}" = set; then
4054    echo $ECHO_N "(cached) $ECHO_C" >&6
4055   else
4056 <  if test "x$F90LIBS" != "x"; then
4057 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4056 >  if test "x$FCLIBS" != "x"; then
4057 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4058   else
4059  
3431 ac_ext=f90
3432 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3433 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3434 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3435
4060   cat >conftest.$ac_ext <<_ACEOF
4061 +      program main
4062  
4063 < program main
3439 <
3440 <
3441 < end program main
3442 <
4063 >      end
4064   _ACEOF
4065  
4066   # Compile and link our simple test program by passing a flag (argument
4067 < # 1 to this macro) to the Fortran 90 compiler in order to get
4068 < # "verbose" output that we can then parse for the Fortran 90 linker
4067 > # 1 to this macro) to the Fortran compiler in order to get
4068 > # "verbose" output that we can then parse for the Fortran linker
4069   # flags.
4070 < ac_save_F90FLAGS=$F90FLAGS
4071 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4070 > ac_save_FFLAGS=$FCFLAGS
4071 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4072 > (eval echo $as_me:4072: \"$ac_link\") >&5
4073 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4074 > echo "$ac_fc_v_output" >&5
4075 > FCFLAGS=$ac_save_FFLAGS
4076  
4077 < (eval echo $as_me:3452: \"$ac_link\") >&5
3453 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3454 < echo "$ac_f90_v_output" >&5
3455 < F90FLAGS=$ac_save_F90FLAGS
4077 > rm -f conftest*
4078  
4079 < rm -f conftest.*
4080 < ac_ext=f90
4081 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4082 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4083 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4079 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4080 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4081 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4082 > ac_fc_v_output="`echo $ac_fc_v_output |
4083 >        grep 'LPATH is:' |
4084 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4085  
4086 < # If we are using xlf then replace all the commas with spaces.
4087 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4088 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4089 < fi
4086 > case $ac_fc_v_output in
4087 >  # If we are using xlf then replace all the commas with spaces.
4088 >  *xlfentry*)
4089 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4090  
4091 < # If we are using Cray Fortran then delete quotes.
4092 < # Use "\"" instead of '"' for font-lock-mode.
4093 < # FIXME: a more general fix for quoted arguments with spaces?
4094 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3472 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3473 < fi
4091 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4092 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4093 >  *mGLOB_options_string*)
4094 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4095  
4096 < ac_cv_f90libs=
4096 >  # If we are using Cray Fortran then delete quotes.
4097 >  # Use "\"" instead of '"' for font-lock-mode.
4098 >  # FIXME: a more general fix for quoted arguments with spaces?
4099 >  *cft90*)
4100 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4101 > esac
4102  
4103 +
4104 +
4105 + ac_cv_fc_libs=
4106 +
4107   # Save positional arguments (if any)
4108   ac_save_positional="$@"
4109  
4110 < set X $ac_f90_v_output
4110 > set X $ac_fc_v_output
4111   while test $# != 1; do
4112    shift
4113    ac_arg=$1
4114    case $ac_arg in
4115          [\\/]*.a | ?:[\\/]*.a)
4116              ac_exists=false
4117 <  for ac_i in $ac_cv_f90libs; do
4117 >  for ac_i in $ac_cv_fc_libs; do
4118      if test x"$ac_arg" = x"$ac_i"; then
4119        ac_exists=true
4120        break
# Line 3494 | Line 4124 | else
4124    if test x"$ac_exists" = xtrue; then
4125    :
4126   else
4127 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4127 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4128   fi
4129  
4130            ;;
4131          -bI:*)
4132              ac_exists=false
4133 <  for ac_i in $ac_cv_f90libs; do
4133 >  for ac_i in $ac_cv_fc_libs; do
4134      if test x"$ac_arg" = x"$ac_i"; then
4135        ac_exists=true
4136        break
# Line 3512 | Line 4142 | else
4142   else
4143    if test "$ac_compiler_gnu" = yes; then
4144    for ac_link_opt in $ac_arg; do
4145 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4145 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4146    done
4147   else
4148 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4148 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4149   fi
4150   fi
4151  
4152            ;;
4153            # Ignore these flags.
4154 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4154 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4155            ;;
4156          -lkernel32)
4157 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4157 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4158            ;;
4159          -[LRuY])
4160            # These flags, when seen by themselves, take an argument.
4161            # We remove the space between option and argument and re-iterate
4162            # unless we find an empty arg or a new option (starting with -)
4163            case $2 in
4164 <             "" | -*);;
4165 <             *)
4164 >             "" | -*);;
4165 >             *)
4166                  ac_arg="$ac_arg$2"
3537
4167                  shift; shift
4168                  set X $ac_arg "$@"
4169                  ;;
# Line 3543 | Line 4172 | fi
4172          -YP,*)
4173            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4174                ac_exists=false
4175 <  for ac_i in $ac_cv_f90libs; do
4175 >  for ac_i in $ac_cv_fc_libs; do
4176      if test x"$ac_j" = x"$ac_i"; then
4177        ac_exists=true
4178        break
# Line 3554 | Line 4183 | else
4183    :
4184   else
4185    ac_arg="$ac_arg $ac_j"
4186 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4186 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4187   fi
4188  
4189            done
4190            ;;
4191          -[lLR]*)
4192              ac_exists=false
4193 <  for ac_i in $ac_cv_f90libs; do
4193 >  for ac_i in $ac_cv_fc_libs; do
4194      if test x"$ac_arg" = x"$ac_i"; then
4195        ac_exists=true
4196        break
# Line 3571 | Line 4200 | else
4200    if test x"$ac_exists" = xtrue; then
4201    :
4202   else
4203 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4203 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4204   fi
4205  
4206            ;;
# Line 3586 | Line 4215 | case `(uname -sr) 2>/dev/null` in
4215   # must begin with a "/").
4216   case `(uname -sr) 2>/dev/null` in
4217     "SunOS 5"*)
4218 <      ac_ld_run_path=`echo $ac_f90_v_output |
4218 >      ac_ld_run_path=`echo $ac_fc_v_output |
4219                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4220        test "x$ac_ld_run_path" != x &&
3592
4221          if test "$ac_compiler_gnu" = yes; then
4222    for ac_link_opt in $ac_ld_run_path; do
4223 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4223 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4224    done
4225   else
4226 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4226 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4227   fi
4228        ;;
4229   esac
4230 < fi # test "x$F90LIBS" = "x"
4231 <
4232 < fi
4233 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4234 < echo "${ECHO_T}$ac_cv_flibs" >&6
4235 < F90LIBS="$ac_cv_f90libs"
4236 <
4237 < ac_ext=f90
4238 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4239 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4240 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4241 <
4242 <
4243 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4244 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4245 < if test "${ac_cv_f90_mangling+set}" = set; then
4246 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4247 < else
4248 <  ac_ext=f90
4249 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4250 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4251 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4252 < cat >conftest.$ac_ext <<_ACEOF
4253 < subroutine foobar()
4254 < return
4255 < end
4256 < subroutine foo_bar()
4257 < return
4258 < end
4259 < _ACEOF
4260 < rm -f conftest.$ac_objext
4261 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4262 <  (eval $ac_compile) 2>&5
4263 <  ac_status=$?
4264 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4265 <  (exit $ac_status); } &&
4266 <         { ac_try='test -s conftest.$ac_objext'
4267 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4268 <  (eval $ac_try) 2>&5
4269 <  ac_status=$?
4270 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4271 <  (exit $ac_status); }; }; then
4272 <  mv conftest.$ac_objext cf90_test.$ac_objext
4273 <
4274 <  ac_ext=c
4275 < ac_cpp='$CPP $CPPFLAGS'
4276 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4277 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4278 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4279 <
4280 <  ac_save_LIBS=$LIBS
4281 <  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
4282 <
4283 <  ac_success=no
4284 <  for ac_foobar in foobar FOOBAR; do
4285 <    for ac_underscore in "" "_"; do
4286 <      ac_func="$ac_foobar$ac_underscore"
4287 <      cat >conftest.$ac_ext <<_ACEOF
4288 < #line $LINENO "configure"
4289 < /* confdefs.h.  */
4290 < _ACEOF
4291 < cat confdefs.h >>conftest.$ac_ext
4292 < cat >>conftest.$ac_ext <<_ACEOF
4293 < /* end confdefs.h.  */
4294 <
4295 < /* Override any gcc2 internal prototype to avoid an error.  */
4296 < #ifdef __cplusplus
4297 < extern "C"
4298 < #endif
4299 < /* We use char because int might match the return type of a gcc2
4300 <   builtin and then its argument prototype would still apply.  */
4301 < char $ac_func ();
4302 < int
4303 < main ()
4304 < {
4305 < $ac_func ();
4306 <  ;
4307 <  return 0;
4308 < }
4309 < _ACEOF
4310 < rm -f conftest.$ac_objext conftest$ac_exeext
4311 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4312 <  (eval $ac_link) 2>&5
4313 <  ac_status=$?
4314 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4315 <  (exit $ac_status); } &&
4316 <         { ac_try='test -s conftest$ac_exeext'
4317 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4318 <  (eval $ac_try) 2>&5
4319 <  ac_status=$?
4320 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4321 <  (exit $ac_status); }; }; then
4322 <  ac_success=yes; break 2
4323 < else
4324 <  echo "$as_me: failed program was:" >&5
4325 < sed 's/^/| /' conftest.$ac_ext >&5
4326 <
4327 < fi
4328 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
4329 <    done
4330 <  done
4331 <
4332 <  if test "$ac_success" = "yes"; then
4333 <     case $ac_foobar in
4334 <        foobar)
4335 <           ac_case=lower
4336 <           ac_foo_bar=foo_bar
4337 <           ;;
4338 <        FOOBAR)
4339 <           ac_case=upper
4340 <           ac_foo_bar=FOO_BAR
4341 <           ;;
4342 <     esac
4343 <
4344 <     ac_success_extra=no
4345 <     for ac_extra in "" "_"; do
4346 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4347 <
4348 <        cat >conftest.$ac_ext <<_ACEOF
4349 < #line $LINENO "configure"
4350 < /* confdefs.h.  */
4351 < _ACEOF
4352 < cat confdefs.h >>conftest.$ac_ext
4353 < cat >>conftest.$ac_ext <<_ACEOF
4354 < /* end confdefs.h.  */
4355 <
4356 < /* Override any gcc2 internal prototype to avoid an error.  */
4357 < #ifdef __cplusplus
4358 < extern "C"
4359 < #endif
4360 < /* We use char because int might match the return type of a gcc2
4361 <   builtin and then its argument prototype would still apply.  */
4362 < char $ac_func ();
4363 < int
4364 < main ()
4365 < {
4366 < $ac_func ();
4367 <  ;
4368 <  return 0;
4369 < }
4370 < _ACEOF
4371 < rm -f conftest.$ac_objext conftest$ac_exeext
4372 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4373 <  (eval $ac_link) 2>&5
4374 <  ac_status=$?
4375 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4376 <  (exit $ac_status); } &&
4377 <         { ac_try='test -s conftest$ac_exeext'
4378 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4379 <  (eval $ac_try) 2>&5
4380 <  ac_status=$?
4381 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4382 <  (exit $ac_status); }; }; then
4383 <  ac_success_extra=yes; break
4384 < else
4385 <  echo "$as_me: failed program was:" >&5
4386 < sed 's/^/| /' conftest.$ac_ext >&5
4387 <
4388 < fi
4389 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
4390 <     done
4391 <
4392 <     if test "$ac_success_extra" = "yes"; then
4393 <        ac_cv_f90_mangling="$ac_case case"
4394 <        if test -z "$ac_underscore"; then
4395 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4396 <        else
4397 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4398 <
4399 <        fi
4400 <        if test -z "$ac_extra"; then
4401 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4402 <        else
4403 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4404 <        fi
4405 <      else
4406 <        ac_cv_f90_mangling="unknown"
4407 <      fi
4408 <  else
4409 <     ac_cv_f90_mangling="unknown"
4410 <
4411 <  fi
4412 <
4413 <  LIBS=$ac_save_LIBS
4414 <  ac_ext=f90
4415 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4416 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4417 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4418 <  rm -f cf90_test* conftest*
4419 < else
4420 <  echo "$as_me: failed program was:" >&5
4421 < sed 's/^/| /' conftest.$ac_ext >&5
4422 <
4423 < fi
4424 < rm -f conftest.$ac_objext conftest.$ac_ext
4425 < ac_ext=f90
4426 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4427 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4428 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4429 <
4430 < fi
4431 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4432 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4433 <
4434 <
4435 <
4436 < case $ac_cv_f90_mangling in
4437 <  "lower case, no underscore, no extra underscore")
4438 <          cat >>confdefs.h <<\_ACEOF
4439 < #define F90_FUNC(name,NAME) name
4440 < _ACEOF
4441 <
4442 <          cat >>confdefs.h <<\_ACEOF
4443 < #define F90_FUNC_(name,NAME) name
4444 < _ACEOF
4445 < ;;
4446 <  "lower case, no underscore, extra underscore")
4447 <          cat >>confdefs.h <<\_ACEOF
4448 < #define F90_FUNC(name,NAME) name
4449 < _ACEOF
4450 <
4451 <          cat >>confdefs.h <<\_ACEOF
4452 < #define F90_FUNC_(name,NAME) name ## _
4453 < _ACEOF
4454 < ;;
4455 <  "lower case, underscore, no extra underscore")
4456 <          cat >>confdefs.h <<\_ACEOF
4457 < #define F90_FUNC(name,NAME) name ## _
4458 < _ACEOF
4459 <
4460 <          cat >>confdefs.h <<\_ACEOF
4461 < #define F90_FUNC_(name,NAME) name ## _
4462 < _ACEOF
4463 < ;;
4464 <  "lower case, underscore, extra underscore")
4465 <          cat >>confdefs.h <<\_ACEOF
4466 < #define F90_FUNC(name,NAME) name ## _
4467 < _ACEOF
4468 <
4469 <          cat >>confdefs.h <<\_ACEOF
4470 < #define F90_FUNC_(name,NAME) name ## __
4471 < _ACEOF
4472 < ;;
4473 <  "upper case, no underscore, no extra underscore")
4474 <          cat >>confdefs.h <<\_ACEOF
4475 < #define F90_FUNC(name,NAME) NAME
4476 < _ACEOF
4477 <
4478 <          cat >>confdefs.h <<\_ACEOF
4479 < #define F90_FUNC_(name,NAME) NAME
4480 < _ACEOF
4481 < ;;
4482 <  "upper case, no underscore, extra underscore")
4483 <          cat >>confdefs.h <<\_ACEOF
4484 < #define F90_FUNC(name,NAME) NAME
4485 < _ACEOF
4486 <
4487 <          cat >>confdefs.h <<\_ACEOF
4488 < #define F90_FUNC_(name,NAME) NAME ## _
4489 < _ACEOF
4490 < ;;
4491 <  "upper case, underscore, no extra underscore")
4492 <          cat >>confdefs.h <<\_ACEOF
4493 < #define F90_FUNC(name,NAME) NAME ## _
4494 < _ACEOF
4495 <
4496 <          cat >>confdefs.h <<\_ACEOF
4497 < #define F90_FUNC_(name,NAME) NAME ## _
4498 < _ACEOF
4499 < ;;
4500 <  "upper case, underscore, extra underscore")
4501 <          cat >>confdefs.h <<\_ACEOF
4502 < #define F90_FUNC(name,NAME) NAME ## _
4503 < _ACEOF
4504 <
4505 <          cat >>confdefs.h <<\_ACEOF
4506 < #define F90_FUNC_(name,NAME) NAME ## __
4507 < _ACEOF
4508 < ;;
4509 <  *)
4510 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4511 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4512 <          ;;
4513 < esac
4514 <
4515 <
4516 <
4517 <
4518 <
4519 < echo "$as_me:$LINENO: checking for module suffix" >&5
4520 < echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
4521 < rm -f conftest*
4522 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4523 < rm -f work*
4524 < cat >conftest.f90 <<EOF
4525 <        module conftest
4526 <        integer n
4527 <        parameter (n=1)
4528 <        end module conftest
4529 < EOF
4530 < # SGI and absoft compilers generates module name in upper case!
4531 < testname="conftest"
4532 < modcase="lower"
4533 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4534 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
4535 <    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
4536 <    if test -z "$MOD" ; then
4537 <        MOD=`ls CONFTEST* 2>/dev/null \
4538 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
4539 <        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
4540 <        if test -n "$MOD" ; then
4541 <            testname="CONFTEST"
4542 <            modcase="upper"
4543 <        fi
4544 <    fi
4545 <    if test -z "$MOD" ; then
4546 <        echo "$as_me:$LINENO: result: unknown" >&5
4547 < echo "${ECHO_T}unknown" >&6
4548 <        # Use mod if we can't figure it out
4549 <        MOD="mod"
4550 <    else
4551 <        echo "$as_me:$LINENO: result: $MOD" >&5
4552 < echo "${ECHO_T}$MOD" >&6
4553 <    fi
4554 <    if test -s work.pcl ; then
4555 <        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
4556 < echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
4557 <    fi
4558 < else
4559 <    echo "$as_me:$LINENO: result: unknown" >&5
4560 < echo "${ECHO_T}unknown" >&6
4561 < fi
4562 <
4563 <
4564 <
4565 <
4566 <
4567 < # Check for module include path (some use -I, some (Solaris) use -M, some
4568 < # (absoft) use -p).
4569 < # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
4570 < # specified, work.pcl and work.pc are created.  However, if you specify
4571 < # a file, it must contain a the name of a file ending in .pc .  Ugh!
4572 < # Use the module made above
4573 < echo "$as_me:$LINENO: checking for module directory path flag" >&5
4574 < echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
4575 < rm -f conftest*
4576 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4577 < rm -f work*
4578 < cat >conftest.f90 <<EOF
4579 <        module conftest
4580 <        integer n
4581 <        parameter (n=1)
4582 <        end module conftest
4583 < EOF
4584 < # SGI and absoft compilers generates module name in upper case!
4585 < testname="conftest"
4586 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4587 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
4588 <   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
4589 <   if test -n "$mod" ; then
4590 <      testname="CONFTEST"
4591 <   fi
4592 <   madedir=0
4593 <   if test ! -d conf ; then mkdir conf ; madedir=1; fi
4594 <   cp $testname.$MOD conf
4595 <   rm -f conftest* CONFTEST*
4596 <   cat >conftest1.f90 <<EOF
4597 <        program main
4598 <        use conftest
4599 <        print *, n
4600 <        end
4601 < EOF
4602 <   F90_WORK_FILES_ARG=""
4603 <   F90MODINCSPEC=""
4604 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
4605 <       MODDIRFLAG="-I"
4606 <       F90MODINCSPEC="-I<dir>"
4607 <       echo "$as_me:$LINENO: result: -I" >&5
4608 < echo "${ECHO_T}-I" >&6
4609 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
4610 <       MODDIRFLAG="-M"
4611 <       F90MODINCSPEC="-M<dir>"
4612 <       echo "$as_me:$LINENO: result: -M" >&5
4613 < echo "${ECHO_T}-M" >&6
4614 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
4615 <       MODDIRFLAG="-p"
4616 <       F90MODINCSPEC="-p<dir>"
4617 <       echo "$as_me:$LINENO: result: -p" >&5
4618 < echo "${ECHO_T}-p" >&6
4619 <   elif test -s work.pc ; then
4620 <        cp work.pc conf/mpimod.pc
4621 <        echo "mpimod.pc" > conf/mpimod.pcl
4622 <        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
4623 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
4624 <            MODDIRFLAG='-cl,mpimod.pcl'
4625 <            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
4626 < echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
4627 <            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
4628 <            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
4629 <
4630 <        else
4631 <            # The version of the Intel compiler that I have refuses to let
4632 <            # you put the "work catalog" list anywhere but the current
4633 <            # directory. For example, you cannot in
4634 <         :
4635 <        fi
4636 <   fi
4637 <   if test -z "MODDIRFLAG" ; then
4638 <       echo "$as_me:$LINENO: result: unknown" >&5
4639 < echo "${ECHO_T}unknown" >&6
4640 <   fi
4641 <
4642 <
4643 <   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
4644 <   if test $madedir = 1 ; then rmdir conf ; fi
4645 < fi
4646 <
4647 <
4648 < echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
4649 < echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
4650 < if test "${ac_cv_f90_module_names+set}" = set; then
4651 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4652 < else
4653 <  ac_ext=f90
4654 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4655 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4656 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4657 <
4658 < # carry out the test in a new directory, so that we don't miss anything
4659 < mkdir conftest
4660 < cd conftest
4661 < cat >conftest.$ac_ext <<_ACEOF
4662 < MODULE Bar
4663 < END MODULE Bar
4664 < _ACEOF
4665 < rm -f conftest.$ac_objext
4666 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4667 <  (eval $ac_compile) 2>&5
4230 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4231 >
4232 > fi
4233 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4234 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4235 > FCLIBS="$ac_cv_fc_libs"
4236 >
4237 >
4238 > ac_ext=${FC_SRCEXT-f}
4239 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4240 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4241 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4242 >
4243 >
4244 > ac_ext=${FC_SRCEXT-f}
4245 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4246 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4247 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4248 >
4249 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4250 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4251 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4252 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4253 > else
4254 >  ac_fc_dm_save_LIBS=$LIBS
4255 > LIBS="$LIBS $FCLIBS"
4256 > ac_fortran_dm_var=FC_DUMMY_MAIN
4257 > ac_ext=c
4258 > ac_cpp='$CPP $CPPFLAGS'
4259 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4260 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4261 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4262 >
4263 > # First, try linking without a dummy main:
4264 > cat >conftest.$ac_ext <<_ACEOF
4265 > /* confdefs.h.  */
4266 > _ACEOF
4267 > cat confdefs.h >>conftest.$ac_ext
4268 > cat >>conftest.$ac_ext <<_ACEOF
4269 > /* end confdefs.h.  */
4270 >
4271 > #ifdef FC_DUMMY_MAIN
4272 > #ifndef FC_DUMMY_MAIN_EQ_F77
4273 > #  ifdef __cplusplus
4274 >     extern "C"
4275 > #  endif
4276 >   int FC_DUMMY_MAIN() { return 1; }
4277 > #endif
4278 > #endif
4279 > int
4280 > main ()
4281 > {
4282 >
4283 >  ;
4284 >  return 0;
4285 > }
4286 > _ACEOF
4287 > rm -f conftest.$ac_objext conftest$ac_exeext
4288 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4289 >  (eval $ac_link) 2>conftest.er1
4290 >  ac_status=$?
4291 >  grep -v '^ *+' conftest.er1 >conftest.err
4292 >  rm -f conftest.er1
4293 >  cat conftest.err >&5
4294 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4295 >  (exit $ac_status); } &&
4296 >         { ac_try='test -z "$ac_c_werror_flag"
4297 >                         || test ! -s conftest.err'
4298 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4299 >  (eval $ac_try) 2>&5
4300 >  ac_status=$?
4301 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4302 >  (exit $ac_status); }; } &&
4303 >         { ac_try='test -s conftest$ac_exeext'
4304 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4305 >  (eval $ac_try) 2>&5
4306 >  ac_status=$?
4307 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4308 >  (exit $ac_status); }; }; then
4309 >  ac_cv_fortran_dummy_main=none
4310 > else
4311 >  echo "$as_me: failed program was:" >&5
4312 > sed 's/^/| /' conftest.$ac_ext >&5
4313 >
4314 > ac_cv_fortran_dummy_main=unknown
4315 > fi
4316 > rm -f conftest.err conftest.$ac_objext \
4317 >      conftest$ac_exeext conftest.$ac_ext
4318 >
4319 > if test $ac_cv_fortran_dummy_main = unknown; then
4320 >   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4321 >     cat >conftest.$ac_ext <<_ACEOF
4322 > /* confdefs.h.  */
4323 > _ACEOF
4324 > cat confdefs.h >>conftest.$ac_ext
4325 > cat >>conftest.$ac_ext <<_ACEOF
4326 > /* end confdefs.h.  */
4327 > #define $ac_fortran_dm_var $ac_func
4328 > #ifdef FC_DUMMY_MAIN
4329 > #ifndef FC_DUMMY_MAIN_EQ_F77
4330 > #  ifdef __cplusplus
4331 >     extern "C"
4332 > #  endif
4333 >   int FC_DUMMY_MAIN() { return 1; }
4334 > #endif
4335 > #endif
4336 > int
4337 > main ()
4338 > {
4339 >
4340 >  ;
4341 >  return 0;
4342 > }
4343 > _ACEOF
4344 > rm -f conftest.$ac_objext conftest$ac_exeext
4345 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4346 >  (eval $ac_link) 2>conftest.er1
4347 >  ac_status=$?
4348 >  grep -v '^ *+' conftest.er1 >conftest.err
4349 >  rm -f conftest.er1
4350 >  cat conftest.err >&5
4351 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4352 >  (exit $ac_status); } &&
4353 >         { ac_try='test -z "$ac_c_werror_flag"
4354 >                         || test ! -s conftest.err'
4355 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4356 >  (eval $ac_try) 2>&5
4357 >  ac_status=$?
4358 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4359 >  (exit $ac_status); }; } &&
4360 >         { ac_try='test -s conftest$ac_exeext'
4361 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4362 >  (eval $ac_try) 2>&5
4363 >  ac_status=$?
4364 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4365 >  (exit $ac_status); }; }; then
4366 >  ac_cv_fortran_dummy_main=$ac_func; break
4367 > else
4368 >  echo "$as_me: failed program was:" >&5
4369 > sed 's/^/| /' conftest.$ac_ext >&5
4370 >
4371 > fi
4372 > rm -f conftest.err conftest.$ac_objext \
4373 >      conftest$ac_exeext conftest.$ac_ext
4374 >   done
4375 > fi
4376 > ac_ext=${FC_SRCEXT-f}
4377 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4378 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4379 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4380 > ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4381 > rm -f conftest*
4382 > LIBS=$ac_fc_dm_save_LIBS
4383 >
4384 > fi
4385 > echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4386 > echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4387 > FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4388 > if test "$FC_DUMMY_MAIN" != unknown; then
4389 >  if test $FC_DUMMY_MAIN != none; then
4390 >
4391 > cat >>confdefs.h <<_ACEOF
4392 > #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4393 > _ACEOF
4394 >
4395 >  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4396 >
4397 > cat >>confdefs.h <<\_ACEOF
4398 > #define FC_DUMMY_MAIN_EQ_F77 1
4399 > _ACEOF
4400 >
4401 >  fi
4402 > fi
4403 > else
4404 >  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4405 > See \`config.log' for more details." >&5
4406 > echo "$as_me: error: linking to Fortran libraries from C fails
4407 > See \`config.log' for more details." >&2;}
4408 >   { (exit 1); exit 1; }; }
4409 > fi
4410 >
4411 >
4412 > ac_ext=${FC_SRCEXT-f}
4413 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4414 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4415 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4416 >
4417 > ac_ext=${FC_SRCEXT-f}
4418 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4419 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4420 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4421 > echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4422 > echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4423 > if test "${ac_cv_fc_mangling+set}" = set; then
4424 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4425 > else
4426 >  cat >conftest.$ac_ext <<_ACEOF
4427 >      subroutine foobar()
4428 >      return
4429 >      end
4430 >      subroutine foo_bar()
4431 >      return
4432 >      end
4433 > _ACEOF
4434 > rm -f conftest.$ac_objext
4435 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4436 >  (eval $ac_compile) 2>conftest.er1
4437 >  ac_status=$?
4438 >  grep -v '^ *+' conftest.er1 >conftest.err
4439 >  rm -f conftest.er1
4440 >  cat conftest.err >&5
4441 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4442 >  (exit $ac_status); } &&
4443 >         { ac_try='test -z "$ac_fc_werror_flag"
4444 >                         || test ! -s conftest.err'
4445 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4446 >  (eval $ac_try) 2>&5
4447 >  ac_status=$?
4448 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4449 >  (exit $ac_status); }; } &&
4450 >         { ac_try='test -s conftest.$ac_objext'
4451 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4452 >  (eval $ac_try) 2>&5
4453 >  ac_status=$?
4454 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4455 >  (exit $ac_status); }; }; then
4456 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4457 >
4458 >  ac_save_LIBS=$LIBS
4459 >  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4460 >
4461 >  ac_ext=c
4462 > ac_cpp='$CPP $CPPFLAGS'
4463 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4464 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4465 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4466 >  ac_success=no
4467 >  for ac_foobar in foobar FOOBAR; do
4468 >    for ac_underscore in "" "_"; do
4469 >      ac_func="$ac_foobar$ac_underscore"
4470 >      cat >conftest.$ac_ext <<_ACEOF
4471 > /* confdefs.h.  */
4472 > _ACEOF
4473 > cat confdefs.h >>conftest.$ac_ext
4474 > cat >>conftest.$ac_ext <<_ACEOF
4475 > /* end confdefs.h.  */
4476 >
4477 > /* Override any gcc2 internal prototype to avoid an error.  */
4478 > #ifdef __cplusplus
4479 > extern "C"
4480 > #endif
4481 > /* We use char because int might match the return type of a gcc2
4482 >   builtin and then its argument prototype would still apply.  */
4483 > char $ac_func ();
4484 > #ifdef FC_DUMMY_MAIN
4485 > #ifndef FC_DUMMY_MAIN_EQ_F77
4486 > #  ifdef __cplusplus
4487 >     extern "C"
4488 > #  endif
4489 >   int FC_DUMMY_MAIN() { return 1; }
4490 > #endif
4491 > #endif
4492 > int
4493 > main ()
4494 > {
4495 > $ac_func ();
4496 >  ;
4497 >  return 0;
4498 > }
4499 > _ACEOF
4500 > rm -f conftest.$ac_objext conftest$ac_exeext
4501 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4502 >  (eval $ac_link) 2>conftest.er1
4503 >  ac_status=$?
4504 >  grep -v '^ *+' conftest.er1 >conftest.err
4505 >  rm -f conftest.er1
4506 >  cat conftest.err >&5
4507 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4508 >  (exit $ac_status); } &&
4509 >         { ac_try='test -z "$ac_c_werror_flag"
4510 >                         || test ! -s conftest.err'
4511 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4512 >  (eval $ac_try) 2>&5
4513 >  ac_status=$?
4514 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4515 >  (exit $ac_status); }; } &&
4516 >         { ac_try='test -s conftest$ac_exeext'
4517 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4518 >  (eval $ac_try) 2>&5
4519 >  ac_status=$?
4520 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4521 >  (exit $ac_status); }; }; then
4522 >  ac_success=yes; break 2
4523 > else
4524 >  echo "$as_me: failed program was:" >&5
4525 > sed 's/^/| /' conftest.$ac_ext >&5
4526 >
4527 > fi
4528 > rm -f conftest.err conftest.$ac_objext \
4529 >      conftest$ac_exeext conftest.$ac_ext
4530 >    done
4531 >  done
4532 >  ac_ext=${FC_SRCEXT-f}
4533 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4534 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4535 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4536 >
4537 >  if test "$ac_success" = "yes"; then
4538 >     case $ac_foobar in
4539 >        foobar)
4540 >           ac_case=lower
4541 >           ac_foo_bar=foo_bar
4542 >           ;;
4543 >        FOOBAR)
4544 >           ac_case=upper
4545 >           ac_foo_bar=FOO_BAR
4546 >           ;;
4547 >     esac
4548 >
4549 >     ac_ext=c
4550 > ac_cpp='$CPP $CPPFLAGS'
4551 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4552 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4553 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4554 >     ac_success_extra=no
4555 >     for ac_extra in "" "_"; do
4556 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4557 >        cat >conftest.$ac_ext <<_ACEOF
4558 > /* confdefs.h.  */
4559 > _ACEOF
4560 > cat confdefs.h >>conftest.$ac_ext
4561 > cat >>conftest.$ac_ext <<_ACEOF
4562 > /* end confdefs.h.  */
4563 >
4564 > /* Override any gcc2 internal prototype to avoid an error.  */
4565 > #ifdef __cplusplus
4566 > extern "C"
4567 > #endif
4568 > /* We use char because int might match the return type of a gcc2
4569 >   builtin and then its argument prototype would still apply.  */
4570 > char $ac_func ();
4571 > #ifdef FC_DUMMY_MAIN
4572 > #ifndef FC_DUMMY_MAIN_EQ_F77
4573 > #  ifdef __cplusplus
4574 >     extern "C"
4575 > #  endif
4576 >   int FC_DUMMY_MAIN() { return 1; }
4577 > #endif
4578 > #endif
4579 > int
4580 > main ()
4581 > {
4582 > $ac_func ();
4583 >  ;
4584 >  return 0;
4585 > }
4586 > _ACEOF
4587 > rm -f conftest.$ac_objext conftest$ac_exeext
4588 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4589 >  (eval $ac_link) 2>conftest.er1
4590 >  ac_status=$?
4591 >  grep -v '^ *+' conftest.er1 >conftest.err
4592 >  rm -f conftest.er1
4593 >  cat conftest.err >&5
4594 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4595 >  (exit $ac_status); } &&
4596 >         { ac_try='test -z "$ac_c_werror_flag"
4597 >                         || test ! -s conftest.err'
4598 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4599 >  (eval $ac_try) 2>&5
4600 >  ac_status=$?
4601 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4602 >  (exit $ac_status); }; } &&
4603 >         { ac_try='test -s conftest$ac_exeext'
4604 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4605 >  (eval $ac_try) 2>&5
4606 >  ac_status=$?
4607 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4608 >  (exit $ac_status); }; }; then
4609 >  ac_success_extra=yes; break
4610 > else
4611 >  echo "$as_me: failed program was:" >&5
4612 > sed 's/^/| /' conftest.$ac_ext >&5
4613 >
4614 > fi
4615 > rm -f conftest.err conftest.$ac_objext \
4616 >      conftest$ac_exeext conftest.$ac_ext
4617 >     done
4618 >     ac_ext=${FC_SRCEXT-f}
4619 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4620 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4621 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4622 >
4623 >     if test "$ac_success_extra" = "yes"; then
4624 >        ac_cv_fc_mangling="$ac_case case"
4625 >        if test -z "$ac_underscore"; then
4626 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4627 >        else
4628 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4629 >        fi
4630 >        if test -z "$ac_extra"; then
4631 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4632 >        else
4633 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4634 >        fi
4635 >      else
4636 >        ac_cv_fc_mangling="unknown"
4637 >      fi
4638 >  else
4639 >     ac_cv_fc_mangling="unknown"
4640 >  fi
4641 >
4642 >  LIBS=$ac_save_LIBS
4643 >  rm -f cfortran_test* conftest*
4644 > else
4645 >  echo "$as_me: failed program was:" >&5
4646 > sed 's/^/| /' conftest.$ac_ext >&5
4647 >
4648 > { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4649 > See \`config.log' for more details." >&5
4650 > echo "$as_me: error: cannot compile a simple Fortran program
4651 > See \`config.log' for more details." >&2;}
4652 >   { (exit 1); exit 1; }; }
4653 > fi
4654 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4655 >
4656 > fi
4657 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4658 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4659 >
4660 > ac_ext=${FC_SRCEXT-f}
4661 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4662 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4663 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4664 >
4665 > ac_ext=${FC_SRCEXT-f}
4666 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4667 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4668 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4669 >
4670 >
4671 > case $ac_cv_fc_mangling in
4672 >  "lower case, no underscore, no extra underscore")
4673 >          cat >>confdefs.h <<\_ACEOF
4674 > #define FC_FUNC(name,NAME) name
4675 > _ACEOF
4676 >
4677 >          cat >>confdefs.h <<\_ACEOF
4678 > #define FC_FUNC_(name,NAME) name
4679 > _ACEOF
4680 > ;;
4681 >  "lower case, no underscore, extra underscore")
4682 >          cat >>confdefs.h <<\_ACEOF
4683 > #define FC_FUNC(name,NAME) name
4684 > _ACEOF
4685 >
4686 >          cat >>confdefs.h <<\_ACEOF
4687 > #define FC_FUNC_(name,NAME) name ## _
4688 > _ACEOF
4689 > ;;
4690 >  "lower case, underscore, no extra underscore")
4691 >          cat >>confdefs.h <<\_ACEOF
4692 > #define FC_FUNC(name,NAME) name ## _
4693 > _ACEOF
4694 >
4695 >          cat >>confdefs.h <<\_ACEOF
4696 > #define FC_FUNC_(name,NAME) name ## _
4697 > _ACEOF
4698 > ;;
4699 >  "lower case, underscore, extra underscore")
4700 >          cat >>confdefs.h <<\_ACEOF
4701 > #define FC_FUNC(name,NAME) name ## _
4702 > _ACEOF
4703 >
4704 >          cat >>confdefs.h <<\_ACEOF
4705 > #define FC_FUNC_(name,NAME) name ## __
4706 > _ACEOF
4707 > ;;
4708 >  "upper case, no underscore, no extra underscore")
4709 >          cat >>confdefs.h <<\_ACEOF
4710 > #define FC_FUNC(name,NAME) NAME
4711 > _ACEOF
4712 >
4713 >          cat >>confdefs.h <<\_ACEOF
4714 > #define FC_FUNC_(name,NAME) NAME
4715 > _ACEOF
4716 > ;;
4717 >  "upper case, no underscore, extra underscore")
4718 >          cat >>confdefs.h <<\_ACEOF
4719 > #define FC_FUNC(name,NAME) NAME
4720 > _ACEOF
4721 >
4722 >          cat >>confdefs.h <<\_ACEOF
4723 > #define FC_FUNC_(name,NAME) NAME ## _
4724 > _ACEOF
4725 > ;;
4726 >  "upper case, underscore, no extra underscore")
4727 >          cat >>confdefs.h <<\_ACEOF
4728 > #define FC_FUNC(name,NAME) NAME ## _
4729 > _ACEOF
4730 >
4731 >          cat >>confdefs.h <<\_ACEOF
4732 > #define FC_FUNC_(name,NAME) NAME ## _
4733 > _ACEOF
4734 > ;;
4735 >  "upper case, underscore, extra underscore")
4736 >          cat >>confdefs.h <<\_ACEOF
4737 > #define FC_FUNC(name,NAME) NAME ## _
4738 > _ACEOF
4739 >
4740 >          cat >>confdefs.h <<\_ACEOF
4741 > #define FC_FUNC_(name,NAME) NAME ## __
4742 > _ACEOF
4743 > ;;
4744 >  *)
4745 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4746 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4747 >          ;;
4748 > esac
4749 >
4750 > ac_ext=${FC_SRCEXT-f}
4751 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4752 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4753 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4754 >
4755 >
4756 >
4757 > ac_ext=${FC_SRCEXT-f}
4758 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4759 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4760 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4761 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4762 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4763 > if test "${ac_cv_prog_fc_v+set}" = set; then
4764 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4765 > else
4766 >  cat >conftest.$ac_ext <<_ACEOF
4767 >      program main
4768 >
4769 >      end
4770 > _ACEOF
4771 > rm -f conftest.$ac_objext
4772 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4773 >  (eval $ac_compile) 2>conftest.er1
4774 >  ac_status=$?
4775 >  grep -v '^ *+' conftest.er1 >conftest.err
4776 >  rm -f conftest.er1
4777 >  cat conftest.err >&5
4778 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4779 >  (exit $ac_status); } &&
4780 >         { ac_try='test -z "$ac_fc_werror_flag"
4781 >                         || test ! -s conftest.err'
4782 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4783 >  (eval $ac_try) 2>&5
4784 >  ac_status=$?
4785 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4786 >  (exit $ac_status); }; } &&
4787 >         { ac_try='test -s conftest.$ac_objext'
4788 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4789 >  (eval $ac_try) 2>&5
4790 >  ac_status=$?
4791 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4792 >  (exit $ac_status); }; }; then
4793 >  ac_cv_prog_fc_v=
4794 > # Try some options frequently used verbose output
4795 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4796 >  cat >conftest.$ac_ext <<_ACEOF
4797 >      program main
4798 >
4799 >      end
4800 > _ACEOF
4801 >
4802 > # Compile and link our simple test program by passing a flag (argument
4803 > # 1 to this macro) to the Fortran compiler in order to get
4804 > # "verbose" output that we can then parse for the Fortran linker
4805 > # flags.
4806 > ac_save_FFLAGS=$FCFLAGS
4807 > FCFLAGS="$FCFLAGS $ac_verb"
4808 > (eval echo $as_me:4808: \"$ac_link\") >&5
4809 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4810 > echo "$ac_fc_v_output" >&5
4811 > FCFLAGS=$ac_save_FFLAGS
4812 >
4813 > rm -f conftest*
4814 >
4815 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4816 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4817 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4818 > ac_fc_v_output="`echo $ac_fc_v_output |
4819 >        grep 'LPATH is:' |
4820 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4821 >
4822 > case $ac_fc_v_output in
4823 >  # If we are using xlf then replace all the commas with spaces.
4824 >  *xlfentry*)
4825 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4826 >
4827 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4828 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4829 >  *mGLOB_options_string*)
4830 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4831 >
4832 >  # If we are using Cray Fortran then delete quotes.
4833 >  # Use "\"" instead of '"' for font-lock-mode.
4834 >  # FIXME: a more general fix for quoted arguments with spaces?
4835 >  *cft90*)
4836 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4837 > esac
4838 >
4839 >
4840 >  # look for -l* and *.a constructs in the output
4841 >  for ac_arg in $ac_fc_v_output; do
4842 >     case $ac_arg in
4843 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4844 >          ac_cv_prog_fc_v=$ac_verb
4845 >          break 2 ;;
4846 >     esac
4847 >  done
4848 > done
4849 > if test -z "$ac_cv_prog_fc_v"; then
4850 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4851 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4852 > fi
4853 > else
4854 >  echo "$as_me: failed program was:" >&5
4855 > sed 's/^/| /' conftest.$ac_ext >&5
4856 >
4857 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4858 > echo "$as_me: WARNING: compilation failed" >&2;}
4859 > fi
4860 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4861 >
4862 > fi
4863 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4864 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4865 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4866 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4867 > if test "${ac_cv_fc_libs+set}" = set; then
4868 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4869 > else
4870 >  if test "x$FCLIBS" != "x"; then
4871 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4872 > else
4873 >
4874 > cat >conftest.$ac_ext <<_ACEOF
4875 >      program main
4876 >
4877 >      end
4878 > _ACEOF
4879 >
4880 > # Compile and link our simple test program by passing a flag (argument
4881 > # 1 to this macro) to the Fortran compiler in order to get
4882 > # "verbose" output that we can then parse for the Fortran linker
4883 > # flags.
4884 > ac_save_FFLAGS=$FCFLAGS
4885 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4886 > (eval echo $as_me:4886: \"$ac_link\") >&5
4887 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4888 > echo "$ac_fc_v_output" >&5
4889 > FCFLAGS=$ac_save_FFLAGS
4890 >
4891 > rm -f conftest*
4892 >
4893 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4894 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4895 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4896 > ac_fc_v_output="`echo $ac_fc_v_output |
4897 >        grep 'LPATH is:' |
4898 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4899 >
4900 > case $ac_fc_v_output in
4901 >  # If we are using xlf then replace all the commas with spaces.
4902 >  *xlfentry*)
4903 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4904 >
4905 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4906 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4907 >  *mGLOB_options_string*)
4908 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4909 >
4910 >  # If we are using Cray Fortran then delete quotes.
4911 >  # Use "\"" instead of '"' for font-lock-mode.
4912 >  # FIXME: a more general fix for quoted arguments with spaces?
4913 >  *cft90*)
4914 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4915 > esac
4916 >
4917 >
4918 >
4919 > ac_cv_fc_libs=
4920 >
4921 > # Save positional arguments (if any)
4922 > ac_save_positional="$@"
4923 >
4924 > set X $ac_fc_v_output
4925 > while test $# != 1; do
4926 >  shift
4927 >  ac_arg=$1
4928 >  case $ac_arg in
4929 >        [\\/]*.a | ?:[\\/]*.a)
4930 >            ac_exists=false
4931 >  for ac_i in $ac_cv_fc_libs; do
4932 >    if test x"$ac_arg" = x"$ac_i"; then
4933 >      ac_exists=true
4934 >      break
4935 >    fi
4936 >  done
4937 >
4938 >  if test x"$ac_exists" = xtrue; then
4939 >  :
4940 > else
4941 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4942 > fi
4943 >
4944 >          ;;
4945 >        -bI:*)
4946 >            ac_exists=false
4947 >  for ac_i in $ac_cv_fc_libs; do
4948 >    if test x"$ac_arg" = x"$ac_i"; then
4949 >      ac_exists=true
4950 >      break
4951 >    fi
4952 >  done
4953 >
4954 >  if test x"$ac_exists" = xtrue; then
4955 >  :
4956 > else
4957 >  if test "$ac_compiler_gnu" = yes; then
4958 >  for ac_link_opt in $ac_arg; do
4959 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4960 >  done
4961 > else
4962 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4963 > fi
4964 > fi
4965 >
4966 >          ;;
4967 >          # Ignore these flags.
4968 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4969 >          ;;
4970 >        -lkernel32)
4971 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4972 >          ;;
4973 >        -[LRuY])
4974 >          # These flags, when seen by themselves, take an argument.
4975 >          # We remove the space between option and argument and re-iterate
4976 >          # unless we find an empty arg or a new option (starting with -)
4977 >          case $2 in
4978 >             "" | -*);;
4979 >             *)
4980 >                ac_arg="$ac_arg$2"
4981 >                shift; shift
4982 >                set X $ac_arg "$@"
4983 >                ;;
4984 >          esac
4985 >          ;;
4986 >        -YP,*)
4987 >          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4988 >              ac_exists=false
4989 >  for ac_i in $ac_cv_fc_libs; do
4990 >    if test x"$ac_j" = x"$ac_i"; then
4991 >      ac_exists=true
4992 >      break
4993 >    fi
4994 >  done
4995 >
4996 >  if test x"$ac_exists" = xtrue; then
4997 >  :
4998 > else
4999 >  ac_arg="$ac_arg $ac_j"
5000 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5001 > fi
5002 >
5003 >          done
5004 >          ;;
5005 >        -[lLR]*)
5006 >            ac_exists=false
5007 >  for ac_i in $ac_cv_fc_libs; do
5008 >    if test x"$ac_arg" = x"$ac_i"; then
5009 >      ac_exists=true
5010 >      break
5011 >    fi
5012 >  done
5013 >
5014 >  if test x"$ac_exists" = xtrue; then
5015 >  :
5016 > else
5017 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5018 > fi
5019 >
5020 >          ;;
5021 >          # Ignore everything else.
5022 >  esac
5023 > done
5024 > # restore positional arguments
5025 > set X $ac_save_positional; shift
5026 >
5027 > # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5028 > # then we insist that the "run path" must be an absolute path (i.e. it
5029 > # must begin with a "/").
5030 > case `(uname -sr) 2>/dev/null` in
5031 >   "SunOS 5"*)
5032 >      ac_ld_run_path=`echo $ac_fc_v_output |
5033 >                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5034 >      test "x$ac_ld_run_path" != x &&
5035 >        if test "$ac_compiler_gnu" = yes; then
5036 >  for ac_link_opt in $ac_ld_run_path; do
5037 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5038 >  done
5039 > else
5040 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5041 > fi
5042 >      ;;
5043 > esac
5044 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5045 >
5046 > fi
5047 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5048 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
5049 > FCLIBS="$ac_cv_fc_libs"
5050 >
5051 >
5052 > ac_ext=${FC_SRCEXT-f}
5053 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5054 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5055 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5056 >
5057 >
5058 >
5059 > echo "$as_me:$LINENO: checking for module suffix" >&5
5060 > echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5061 > rm -f conftest*
5062 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5063 > rm -f work*
5064 > cat >conftest.$ac_ext <<EOF
5065 >        module conftest
5066 >        integer n
5067 >        parameter (n=1)
5068 >        end module conftest
5069 > EOF
5070 > # SGI and absoft compilers generates module name in upper case!
5071 > testname="conftest"
5072 > modcase="lower"
5073 > if (eval $ac_compile) 2>/dev/null ; then
5074 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5075 >    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5076 >    if test -z "$MOD" ; then
5077 >        MOD=`ls CONFTEST* 2>/dev/null \
5078 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5079 >        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5080 >        if test -n "$MOD" ; then
5081 >            testname="CONFTEST"
5082 >            modcase="upper"
5083 >        fi
5084 >    fi
5085 >    if test -z "$MOD" ; then
5086 >        echo "$as_me:$LINENO: result: unknown" >&5
5087 > echo "${ECHO_T}unknown" >&6
5088 >        # Use mod if we can't figure it out
5089 >        MOD="mod"
5090 >    else
5091 >        echo "$as_me:$LINENO: result: $MOD" >&5
5092 > echo "${ECHO_T}$MOD" >&6
5093 >    fi
5094 >    if test -s work.pcl ; then
5095 >        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
5096 > echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
5097 >    fi
5098 > else
5099 >    echo "$as_me:$LINENO: result: unknown" >&5
5100 > echo "${ECHO_T}unknown" >&6
5101 > fi
5102 >
5103 >
5104 >
5105 >
5106 >
5107 > # Check for module include path (some use -I, some (Solaris) use -M, some
5108 > # (absoft) use -p).
5109 > # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
5110 > # specified, work.pcl and work.pc are created.  However, if you specify
5111 > # a file, it must contain a the name of a file ending in .pc .  Ugh!
5112 > # Use the module made above
5113 > echo "$as_me:$LINENO: checking for module directory path flag" >&5
5114 > echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
5115 > rm -f conftest*
5116 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5117 > rm -f work*
5118 > cat >conftest.$ac_ext <<EOF
5119 >        module conftest
5120 >        integer n
5121 >        parameter (n=1)
5122 >        end module conftest
5123 > EOF
5124 > # SGI and absoft compilers generates module name in upper case!
5125 > testname="conftest"
5126 > if (eval $ac_compile) 2>/dev/null ; then
5127 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5128 >   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5129 >   if test -n "$mod" ; then
5130 >      testname="CONFTEST"
5131 >   fi
5132 >   madedir=0
5133 >   if test ! -d conf ; then mkdir conf ; madedir=1; fi
5134 >   cp $testname.$MOD conf
5135 >   rm -f conftest* CONFTEST*
5136 >   cat >conftest1.$ac_ext <<EOF
5137 >        program main
5138 >        use conftest
5139 >        print *, n
5140 >        end
5141 > EOF
5142 >   F90_WORK_FILES_ARG=""
5143 >   F90MODINCSPEC=""
5144 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5145 >       MODDIRFLAG="-I"
5146 >       F90MODINCSPEC="-I<dir>"
5147 >       echo "$as_me:$LINENO: result: -I" >&5
5148 > echo "${ECHO_T}-I" >&6
5149 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5150 >       MODDIRFLAG="-M"
5151 >       F90MODINCSPEC="-M<dir>"
5152 >       echo "$as_me:$LINENO: result: -M" >&5
5153 > echo "${ECHO_T}-M" >&6
5154 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5155 >       MODDIRFLAG="-p"
5156 >       F90MODINCSPEC="-p<dir>"
5157 >       echo "$as_me:$LINENO: result: -p" >&5
5158 > echo "${ECHO_T}-p" >&6
5159 >   elif test -s work.pc ; then
5160 >        cp work.pc conf/mpimod.pc
5161 >        echo "mpimod.pc" > conf/mpimod.pcl
5162 >        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5163 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5164 >            MODDIRFLAG='-cl,mpimod.pcl'
5165 >            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5166 > echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
5167 >            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
5168 >            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
5169 >
5170 >        else
5171 >            # The version of the Intel compiler that I have refuses to let
5172 >            # you put the "work catalog" list anywhere but the current
5173 >            # directory. For example, you cannot in
5174 >         :
5175 >        fi
5176 >   fi
5177 >   if test -z "MODDIRFLAG" ; then
5178 >       echo "$as_me:$LINENO: result: unknown" >&5
5179 > echo "${ECHO_T}unknown" >&6
5180 >   fi
5181 >
5182 >
5183 >   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
5184 >   if test $madedir = 1 ; then rmdir conf ; fi
5185 > fi
5186 >
5187 >
5188 > echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5189 > echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
5190 > if test "${ac_cv_f90_module_names+set}" = set; then
5191 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5192 > else
5193 >  ac_ext=${FC_SRCEXT-f}
5194 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5195 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5196 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5197 >
5198 > # carry out the test in a new directory, so that we don't miss anything
5199 > mkdir conftest
5200 > cd conftest
5201 > cat >conftest.$ac_ext <<_ACEOF
5202 > MODULE Bar
5203 > END MODULE Bar
5204 > _ACEOF
5205 > rm -f conftest.$ac_objext
5206 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5207 >  (eval $ac_compile) 2>conftest.er1
5208 >  ac_status=$?
5209 >  grep -v '^ *+' conftest.er1 >conftest.err
5210 >  rm -f conftest.er1
5211 >  cat conftest.err >&5
5212 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5213 >  (exit $ac_status); } &&
5214 >         { ac_try='test -z "$ac_fc_werror_flag"
5215 >                         || test ! -s conftest.err'
5216 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5217 >  (eval $ac_try) 2>&5
5218 >  ac_status=$?
5219 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5220 >  (exit $ac_status); }; } &&
5221 >         { ac_try='test -s conftest.$ac_objext'
5222 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5223 >  (eval $ac_try) 2>&5
5224 >  ac_status=$?
5225 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5226 >  (exit $ac_status); }; }; then
5227 >  ac_cv_f90_module_names=
5228 > ac_file_list=*
5229 > for ac_file in $ac_file_list; do
5230 >   case $ac_file in
5231 >      # don't care for original source and object files
5232 >      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
5233 >          :
5234 >          ;;
5235 >      # look for new files derived from the file name
5236 >      *conftest*)
5237 >          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
5238 >            ac_exists=false
5239 >  for ac_i in $ac_cv_f90_module_names; do
5240 >    if test x"$ac_pat" = x"$ac_i"; then
5241 >      ac_exists=true
5242 >      break
5243 >    fi
5244 >  done
5245 >
5246 >  if test x"$ac_exists" = xtrue; then
5247 >  :
5248 > else
5249 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5250 > fi
5251 >
5252 >          ;;
5253 >      # look for new files derived from the module name,
5254 >      # with different case translation schemes
5255 >      *Bar*)
5256 >          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
5257 >            ac_exists=false
5258 >  for ac_i in $ac_cv_f90_module_names; do
5259 >    if test x"$ac_pat" = x"$ac_i"; then
5260 >      ac_exists=true
5261 >      break
5262 >    fi
5263 >  done
5264 >
5265 >  if test x"$ac_exists" = xtrue; then
5266 >  :
5267 > else
5268 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5269 > fi
5270 >
5271 >          ;;
5272 >      *bar*)
5273 >          ac_pat=`echo $ac_file | sed s/bar/%module%/`
5274 >            ac_exists=false
5275 >  for ac_i in $ac_cv_f90_module_names; do
5276 >    if test x"$ac_pat" = x"$ac_i"; then
5277 >      ac_exists=true
5278 >      break
5279 >    fi
5280 >  done
5281 >
5282 >  if test x"$ac_exists" = xtrue; then
5283 >  :
5284 > else
5285 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5286 > fi
5287 >
5288 >          ;;
5289 >      *BAR*)
5290 >          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
5291 >            ac_exists=false
5292 >  for ac_i in $ac_cv_f90_module_names; do
5293 >    if test x"$ac_pat" = x"$ac_i"; then
5294 >      ac_exists=true
5295 >      break
5296 >    fi
5297 >  done
5298 >
5299 >  if test x"$ac_exists" = xtrue; then
5300 >  :
5301 > else
5302 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5303 > fi
5304 >
5305 >          ;;
5306 >       # Other files - we have no idea how they are generated
5307 >       *)
5308 >          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
5309 > echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
5310 >          ;;
5311 >   esac
5312 > done
5313 > if test "x$ac_cv_f90_module_names" = "x"; then
5314 >  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5315 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5316 > fi
5317 >
5318 > else
5319 >  echo "$as_me: failed program was:" >&5
5320 > sed 's/^/| /' conftest.$ac_ext >&5
5321 >
5322 > ac_cv_f90_module_names=
5323 > { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5324 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5325 > fi
5326 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5327 > cd ..
5328 > # cleanup
5329 > rm -rf conftest
5330 > ac_ext=${FC_SRCEXT-f}
5331 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5332 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5333 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5334 >
5335 > fi
5336 > echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
5337 > echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
5338 >
5339 > # We now generate a shell script that will help us to figure out the correct
5340 > # module file names, using the value of ac_cv_f90_module_names
5341 >
5342 > echo "Generating shell script modnam"
5343 >
5344 > cat > scripts/modnam << EOF
5345 > #! /bin/sh
5346 > # This script is auto-generated by configure
5347 > #
5348 > usage="\\
5349 > Usage: \$0 [FILES]
5350 >
5351 > [FILES] are Fortran 90 source files.
5352 > The output is a list of module file names that the Fortran 90 compiler
5353 > generates when compiling [FILES]."
5354 >
5355 > list=
5356 > empty=
5357 >
5358 > if test \$# -eq 0; then
5359 >   echo "\$usage"; exit 0
5360 > fi
5361 >
5362 > while test \$# != 0; do
5363 >
5364 >  file=\$1
5365 >  shift
5366 >
5367 > # strip suffix
5368 >  base=\`echo \$file | sed 's/[.][^.]*$//'\`
5369 >
5370 >  test ! -f \$file && continue
5371 >
5372 > # Look for module definitions and transform them to upper / lower case
5373 >  mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
5374 >  upper=\`echo \$mods | tr a-z A-Z\`
5375 >  lower=\`echo \$mods | tr A-Z a-z\`
5376 >
5377 > # Here, the patterns for generating module file names were inserted by configure
5378 >  for trans in $ac_cv_f90_module_names; do
5379 >
5380 >    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
5381 >    var=empty
5382 >    case \$pat in
5383 >       %MODULE%)
5384 >          var=upper ;;
5385 >       %Module%)
5386 >          var=mods ;;
5387 >       %module%)
5388 >          var=lower ;;
5389 >       %FILE%)
5390 >          test -n "\$mods" && var=base ;;
5391 >    esac
5392 >    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
5393 >    list="\$list \$new"
5394 >  done
5395 > done
5396 >
5397 > echo \$list
5398 > # end of configure-generated script
5399 > EOF
5400 > chmod 755 scripts/modnam
5401 >
5402 > pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
5403 > F90_MODULE_NAMES=empty
5404 > case $pat in
5405 >       %MODULE%)
5406 >          F90_MODULE_NAMES=UPPER ;;
5407 >       %Module%)
5408 >          F90_MODULE_NAMES=Mixed ;;
5409 >       %module%)
5410 >          F90_MODULE_NAMES=lower ;;
5411 >       *)
5412 >          F90_MODULE_NAMES=unknown ;;
5413 > esac
5414 >
5415 > ac_ext=c
5416 > ac_cpp='$CPP $CPPFLAGS'
5417 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5418 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5419 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5420 >
5421 >
5422 > ac_ext=c
5423 > ac_cpp='$CPP $CPPFLAGS'
5424 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5425 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5426 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5427 >
5428 >
5429 >
5430 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5431 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5432 > if test "${ac_cv_lib_m_asin+set}" = set; then
5433 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5434 > else
5435 >  ac_check_lib_save_LIBS=$LIBS
5436 > LIBS="-lm  $LIBS"
5437 > cat >conftest.$ac_ext <<_ACEOF
5438 > /* confdefs.h.  */
5439 > _ACEOF
5440 > cat confdefs.h >>conftest.$ac_ext
5441 > cat >>conftest.$ac_ext <<_ACEOF
5442 > /* end confdefs.h.  */
5443 >
5444 > /* Override any gcc2 internal prototype to avoid an error.  */
5445 > #ifdef __cplusplus
5446 > extern "C"
5447 > #endif
5448 > /* We use char because int might match the return type of a gcc2
5449 >   builtin and then its argument prototype would still apply.  */
5450 > char asin ();
5451 > #ifdef FC_DUMMY_MAIN
5452 > #ifndef FC_DUMMY_MAIN_EQ_F77
5453 > #  ifdef __cplusplus
5454 >     extern "C"
5455 > #  endif
5456 >   int FC_DUMMY_MAIN() { return 1; }
5457 > #endif
5458 > #endif
5459 > int
5460 > main ()
5461 > {
5462 > asin ();
5463 >  ;
5464 >  return 0;
5465 > }
5466 > _ACEOF
5467 > rm -f conftest.$ac_objext conftest$ac_exeext
5468 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5469 >  (eval $ac_link) 2>conftest.er1
5470 >  ac_status=$?
5471 >  grep -v '^ *+' conftest.er1 >conftest.err
5472 >  rm -f conftest.er1
5473 >  cat conftest.err >&5
5474 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5475 >  (exit $ac_status); } &&
5476 >         { ac_try='test -z "$ac_c_werror_flag"
5477 >                         || test ! -s conftest.err'
5478 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5479 >  (eval $ac_try) 2>&5
5480 >  ac_status=$?
5481 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5482 >  (exit $ac_status); }; } &&
5483 >         { ac_try='test -s conftest$ac_exeext'
5484 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5485 >  (eval $ac_try) 2>&5
5486 >  ac_status=$?
5487 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5488 >  (exit $ac_status); }; }; then
5489 >  ac_cv_lib_m_asin=yes
5490 > else
5491 >  echo "$as_me: failed program was:" >&5
5492 > sed 's/^/| /' conftest.$ac_ext >&5
5493 >
5494 > ac_cv_lib_m_asin=no
5495 > fi
5496 > rm -f conftest.err conftest.$ac_objext \
5497 >      conftest$ac_exeext conftest.$ac_ext
5498 > LIBS=$ac_check_lib_save_LIBS
5499 > fi
5500 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5501 > echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5502 > if test $ac_cv_lib_m_asin = yes; then
5503 >  cat >>confdefs.h <<_ACEOF
5504 > #define HAVE_LIBM 1
5505 > _ACEOF
5506 >
5507 >  LIBS="-lm $LIBS"
5508 >
5509 > else
5510 >  exit
5511 > fi
5512 >
5513 >
5514 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5515 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5516 > if test "${ac_cv_header_stdc+set}" = set; then
5517 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5518 > else
5519 >  cat >conftest.$ac_ext <<_ACEOF
5520 > /* confdefs.h.  */
5521 > _ACEOF
5522 > cat confdefs.h >>conftest.$ac_ext
5523 > cat >>conftest.$ac_ext <<_ACEOF
5524 > /* end confdefs.h.  */
5525 > #include <stdlib.h>
5526 > #include <stdarg.h>
5527 > #include <string.h>
5528 > #include <float.h>
5529 >
5530 > #ifdef FC_DUMMY_MAIN
5531 > #ifndef FC_DUMMY_MAIN_EQ_F77
5532 > #  ifdef __cplusplus
5533 >     extern "C"
5534 > #  endif
5535 >   int FC_DUMMY_MAIN() { return 1; }
5536 > #endif
5537 > #endif
5538 > int
5539 > main ()
5540 > {
5541 >
5542 >  ;
5543 >  return 0;
5544 > }
5545 > _ACEOF
5546 > rm -f conftest.$ac_objext
5547 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5548 >  (eval $ac_compile) 2>conftest.er1
5549 >  ac_status=$?
5550 >  grep -v '^ *+' conftest.er1 >conftest.err
5551 >  rm -f conftest.er1
5552 >  cat conftest.err >&5
5553 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5554 >  (exit $ac_status); } &&
5555 >         { ac_try='test -z "$ac_c_werror_flag"
5556 >                         || test ! -s conftest.err'
5557 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5558 >  (eval $ac_try) 2>&5
5559 >  ac_status=$?
5560 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5561 >  (exit $ac_status); }; } &&
5562 >         { ac_try='test -s conftest.$ac_objext'
5563 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5564 >  (eval $ac_try) 2>&5
5565 >  ac_status=$?
5566 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5567 >  (exit $ac_status); }; }; then
5568 >  ac_cv_header_stdc=yes
5569 > else
5570 >  echo "$as_me: failed program was:" >&5
5571 > sed 's/^/| /' conftest.$ac_ext >&5
5572 >
5573 > ac_cv_header_stdc=no
5574 > fi
5575 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5576 >
5577 > if test $ac_cv_header_stdc = yes; then
5578 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5579 >  cat >conftest.$ac_ext <<_ACEOF
5580 > /* confdefs.h.  */
5581 > _ACEOF
5582 > cat confdefs.h >>conftest.$ac_ext
5583 > cat >>conftest.$ac_ext <<_ACEOF
5584 > /* end confdefs.h.  */
5585 > #include <string.h>
5586 >
5587 > _ACEOF
5588 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5589 >  $EGREP "memchr" >/dev/null 2>&1; then
5590 >  :
5591 > else
5592 >  ac_cv_header_stdc=no
5593 > fi
5594 > rm -f conftest*
5595 >
5596 > fi
5597 >
5598 > if test $ac_cv_header_stdc = yes; then
5599 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5600 >  cat >conftest.$ac_ext <<_ACEOF
5601 > /* confdefs.h.  */
5602 > _ACEOF
5603 > cat confdefs.h >>conftest.$ac_ext
5604 > cat >>conftest.$ac_ext <<_ACEOF
5605 > /* end confdefs.h.  */
5606 > #include <stdlib.h>
5607 >
5608 > _ACEOF
5609 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5610 >  $EGREP "free" >/dev/null 2>&1; then
5611 >  :
5612 > else
5613 >  ac_cv_header_stdc=no
5614 > fi
5615 > rm -f conftest*
5616 >
5617 > fi
5618 >
5619 > if test $ac_cv_header_stdc = yes; then
5620 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5621 >  if test "$cross_compiling" = yes; then
5622 >  :
5623 > else
5624 >  cat >conftest.$ac_ext <<_ACEOF
5625 > /* confdefs.h.  */
5626 > _ACEOF
5627 > cat confdefs.h >>conftest.$ac_ext
5628 > cat >>conftest.$ac_ext <<_ACEOF
5629 > /* end confdefs.h.  */
5630 > #include <ctype.h>
5631 > #if ((' ' & 0x0FF) == 0x020)
5632 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5633 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5634 > #else
5635 > # define ISLOWER(c) \
5636 >                   (('a' <= (c) && (c) <= 'i') \
5637 >                     || ('j' <= (c) && (c) <= 'r') \
5638 >                     || ('s' <= (c) && (c) <= 'z'))
5639 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5640 > #endif
5641 >
5642 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5643 > int
5644 > main ()
5645 > {
5646 >  int i;
5647 >  for (i = 0; i < 256; i++)
5648 >    if (XOR (islower (i), ISLOWER (i))
5649 >        || toupper (i) != TOUPPER (i))
5650 >      exit(2);
5651 >  exit (0);
5652 > }
5653 > _ACEOF
5654 > rm -f conftest$ac_exeext
5655 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5656 >  (eval $ac_link) 2>&5
5657 >  ac_status=$?
5658 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5659 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5660 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5661 >  (eval $ac_try) 2>&5
5662 >  ac_status=$?
5663 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5664 >  (exit $ac_status); }; }; then
5665 >  :
5666 > else
5667 >  echo "$as_me: program exited with status $ac_status" >&5
5668 > echo "$as_me: failed program was:" >&5
5669 > sed 's/^/| /' conftest.$ac_ext >&5
5670 >
5671 > ( exit $ac_status )
5672 > ac_cv_header_stdc=no
5673 > fi
5674 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5675 > fi
5676 > fi
5677 > fi
5678 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5679 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
5680 > if test $ac_cv_header_stdc = yes; then
5681 >
5682 > cat >>confdefs.h <<\_ACEOF
5683 > #define STDC_HEADERS 1
5684 > _ACEOF
5685 >
5686 > fi
5687 >
5688 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5689 >
5690 >
5691 >
5692 >
5693 >
5694 >
5695 >
5696 >
5697 >
5698 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5699 >                  inttypes.h stdint.h unistd.h
5700 > do
5701 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5702 > echo "$as_me:$LINENO: checking for $ac_header" >&5
5703 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5704 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
5705 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5706 > else
5707 >  cat >conftest.$ac_ext <<_ACEOF
5708 > /* confdefs.h.  */
5709 > _ACEOF
5710 > cat confdefs.h >>conftest.$ac_ext
5711 > cat >>conftest.$ac_ext <<_ACEOF
5712 > /* end confdefs.h.  */
5713 > $ac_includes_default
5714 >
5715 > #include <$ac_header>
5716 > _ACEOF
5717 > rm -f conftest.$ac_objext
5718 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5719 >  (eval $ac_compile) 2>conftest.er1
5720 >  ac_status=$?
5721 >  grep -v '^ *+' conftest.er1 >conftest.err
5722 >  rm -f conftest.er1
5723 >  cat conftest.err >&5
5724 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5725 >  (exit $ac_status); } &&
5726 >         { ac_try='test -z "$ac_c_werror_flag"
5727 >                         || test ! -s conftest.err'
5728 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5729 >  (eval $ac_try) 2>&5
5730 >  ac_status=$?
5731 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5732 >  (exit $ac_status); }; } &&
5733 >         { ac_try='test -s conftest.$ac_objext'
5734 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5735 >  (eval $ac_try) 2>&5
5736 >  ac_status=$?
5737 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5738 >  (exit $ac_status); }; }; then
5739 >  eval "$as_ac_Header=yes"
5740 > else
5741 >  echo "$as_me: failed program was:" >&5
5742 > sed 's/^/| /' conftest.$ac_ext >&5
5743 >
5744 > eval "$as_ac_Header=no"
5745 > fi
5746 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5747 > fi
5748 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5749 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5750 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
5751 >  cat >>confdefs.h <<_ACEOF
5752 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5753 > _ACEOF
5754 >
5755 > fi
5756 >
5757 > done
5758 >
5759 >
5760 > #
5761 > # Handle user hints
5762 > #
5763 > echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5764 > echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
5765 >
5766 > # Check whether --with-zlib or --without-zlib was given.
5767 > if test "${with_zlib+set}" = set; then
5768 >  withval="$with_zlib"
5769 >  if test "$withval" != no ; then
5770 >  echo "$as_me:$LINENO: result: yes" >&5
5771 > echo "${ECHO_T}yes" >&6
5772 >  if test -d "$withval"
5773 >  then
5774 >    ZLIB_HOME="$withval"
5775 >  else
5776 >    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
5777 > echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
5778 >  fi
5779 > else
5780 >  echo "$as_me:$LINENO: result: no" >&5
5781 > echo "${ECHO_T}no" >&6
5782 > fi
5783 > fi;
5784 >
5785 > ZLIB_HOME=/usr/local
5786 > if test ! -f "${ZLIB_HOME}/include/zlib.h"
5787 > then
5788 >        ZLIB_HOME=/usr
5789 > fi
5790 >
5791 > #
5792 > # Locate zlib, if wanted
5793 > #
5794 > if test -n "${ZLIB_HOME}"
5795 > then
5796 >        ZLIB_OLD_LDFLAGS=$LDFLAGS
5797 >        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5798 >        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5799 >        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5800 >
5801 >
5802 >        ac_ext=c
5803 > ac_cpp='$CPP $CPPFLAGS'
5804 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5805 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5806 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5807 >
5808 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5809 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5810 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5811 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5812 > else
5813 >  ac_check_lib_save_LIBS=$LIBS
5814 > LIBS="-lz  $LIBS"
5815 > cat >conftest.$ac_ext <<_ACEOF
5816 > /* confdefs.h.  */
5817 > _ACEOF
5818 > cat confdefs.h >>conftest.$ac_ext
5819 > cat >>conftest.$ac_ext <<_ACEOF
5820 > /* end confdefs.h.  */
5821 >
5822 > /* Override any gcc2 internal prototype to avoid an error.  */
5823 > #ifdef __cplusplus
5824 > extern "C"
5825 > #endif
5826 > /* We use char because int might match the return type of a gcc2
5827 >   builtin and then its argument prototype would still apply.  */
5828 > char inflateEnd ();
5829 > #ifdef FC_DUMMY_MAIN
5830 > #ifndef FC_DUMMY_MAIN_EQ_F77
5831 > #  ifdef __cplusplus
5832 >     extern "C"
5833 > #  endif
5834 >   int FC_DUMMY_MAIN() { return 1; }
5835 > #endif
5836 > #endif
5837 > int
5838 > main ()
5839 > {
5840 > inflateEnd ();
5841 >  ;
5842 >  return 0;
5843 > }
5844 > _ACEOF
5845 > rm -f conftest.$ac_objext conftest$ac_exeext
5846 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5847 >  (eval $ac_link) 2>conftest.er1
5848 >  ac_status=$?
5849 >  grep -v '^ *+' conftest.er1 >conftest.err
5850 >  rm -f conftest.er1
5851 >  cat conftest.err >&5
5852 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5853 >  (exit $ac_status); } &&
5854 >         { ac_try='test -z "$ac_c_werror_flag"
5855 >                         || test ! -s conftest.err'
5856 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5857 >  (eval $ac_try) 2>&5
5858 >  ac_status=$?
5859 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5860 >  (exit $ac_status); }; } &&
5861 >         { ac_try='test -s conftest$ac_exeext'
5862 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5863 >  (eval $ac_try) 2>&5
5864 >  ac_status=$?
5865 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5866 >  (exit $ac_status); }; }; then
5867 >  ac_cv_lib_z_inflateEnd=yes
5868 > else
5869 >  echo "$as_me: failed program was:" >&5
5870 > sed 's/^/| /' conftest.$ac_ext >&5
5871 >
5872 > ac_cv_lib_z_inflateEnd=no
5873 > fi
5874 > rm -f conftest.err conftest.$ac_objext \
5875 >      conftest$ac_exeext conftest.$ac_ext
5876 > LIBS=$ac_check_lib_save_LIBS
5877 > fi
5878 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5879 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5880 > if test $ac_cv_lib_z_inflateEnd = yes; then
5881 >  zlib_cv_libz=yes
5882 > else
5883 >  zlib_cv_libz=no
5884 > fi
5885 >
5886 >        if test "${ac_cv_header_zlib_h+set}" = set; then
5887 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
5888 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5889 > if test "${ac_cv_header_zlib_h+set}" = set; then
5890 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5891 > fi
5892 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5893 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5894 > else
5895 >  # Is the header compilable?
5896 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
5897 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5898 > cat >conftest.$ac_ext <<_ACEOF
5899 > /* confdefs.h.  */
5900 > _ACEOF
5901 > cat confdefs.h >>conftest.$ac_ext
5902 > cat >>conftest.$ac_ext <<_ACEOF
5903 > /* end confdefs.h.  */
5904 > $ac_includes_default
5905 > #include <zlib.h>
5906 > _ACEOF
5907 > rm -f conftest.$ac_objext
5908 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5909 >  (eval $ac_compile) 2>conftest.er1
5910 >  ac_status=$?
5911 >  grep -v '^ *+' conftest.er1 >conftest.err
5912 >  rm -f conftest.er1
5913 >  cat conftest.err >&5
5914 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5915 >  (exit $ac_status); } &&
5916 >         { ac_try='test -z "$ac_c_werror_flag"
5917 >                         || test ! -s conftest.err'
5918 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5919 >  (eval $ac_try) 2>&5
5920 >  ac_status=$?
5921 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5922 >  (exit $ac_status); }; } &&
5923 >         { ac_try='test -s conftest.$ac_objext'
5924 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5925 >  (eval $ac_try) 2>&5
5926 >  ac_status=$?
5927 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5928 >  (exit $ac_status); }; }; then
5929 >  ac_header_compiler=yes
5930 > else
5931 >  echo "$as_me: failed program was:" >&5
5932 > sed 's/^/| /' conftest.$ac_ext >&5
5933 >
5934 > ac_header_compiler=no
5935 > fi
5936 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5937 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5938 > echo "${ECHO_T}$ac_header_compiler" >&6
5939 >
5940 > # Is the header present?
5941 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
5942 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5943 > cat >conftest.$ac_ext <<_ACEOF
5944 > /* confdefs.h.  */
5945 > _ACEOF
5946 > cat confdefs.h >>conftest.$ac_ext
5947 > cat >>conftest.$ac_ext <<_ACEOF
5948 > /* end confdefs.h.  */
5949 > #include <zlib.h>
5950 > _ACEOF
5951 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5952 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5953 >  ac_status=$?
5954 >  grep -v '^ *+' conftest.er1 >conftest.err
5955 >  rm -f conftest.er1
5956 >  cat conftest.err >&5
5957 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5958 >  (exit $ac_status); } >/dev/null; then
5959 >  if test -s conftest.err; then
5960 >    ac_cpp_err=$ac_c_preproc_warn_flag
5961 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5962 >  else
5963 >    ac_cpp_err=
5964 >  fi
5965 > else
5966 >  ac_cpp_err=yes
5967 > fi
5968 > if test -z "$ac_cpp_err"; then
5969 >  ac_header_preproc=yes
5970 > else
5971 >  echo "$as_me: failed program was:" >&5
5972 > sed 's/^/| /' conftest.$ac_ext >&5
5973 >
5974 >  ac_header_preproc=no
5975 > fi
5976 > rm -f conftest.err conftest.$ac_ext
5977 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5978 > echo "${ECHO_T}$ac_header_preproc" >&6
5979 >
5980 > # So?  What about this header?
5981 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5982 >  yes:no: )
5983 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
5984 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
5985 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
5986 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
5987 >    ac_header_preproc=yes
5988 >    ;;
5989 >  no:yes:* )
5990 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
5991 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
5992 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
5993 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
5994 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
5995 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
5996 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
5997 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
5998 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
5999 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6000 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6001 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6002 >    (
6003 >      cat <<\_ASBOX
6004 > ## ------------------------------ ##
6005 > ## Report this to gezelter@nd.edu ##
6006 > ## ------------------------------ ##
6007 > _ASBOX
6008 >    ) |
6009 >      sed "s/^/$as_me: WARNING:     /" >&2
6010 >    ;;
6011 > esac
6012 > echo "$as_me:$LINENO: checking for zlib.h" >&5
6013 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6014 > if test "${ac_cv_header_zlib_h+set}" = set; then
6015 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6016 > else
6017 >  ac_cv_header_zlib_h=$ac_header_preproc
6018 > fi
6019 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6020 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6021 >
6022 > fi
6023 > if test $ac_cv_header_zlib_h = yes; then
6024 >  zlib_cv_zlib_h=yes
6025 > else
6026 >  zlib_cv_zlib_h=no
6027 > fi
6028 >
6029 >
6030 >        ac_ext=c
6031 > ac_cpp='$CPP $CPPFLAGS'
6032 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6033 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6034 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6035 >
6036 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
6037 >        then
6038 >                #
6039 >                # If both library and header were found, use them
6040 >                #
6041 >
6042 > echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6043 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6044 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
6045 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6046 > else
6047 >  ac_check_lib_save_LIBS=$LIBS
6048 > LIBS="-lz  $LIBS"
6049 > cat >conftest.$ac_ext <<_ACEOF
6050 > /* confdefs.h.  */
6051 > _ACEOF
6052 > cat confdefs.h >>conftest.$ac_ext
6053 > cat >>conftest.$ac_ext <<_ACEOF
6054 > /* end confdefs.h.  */
6055 >
6056 > /* Override any gcc2 internal prototype to avoid an error.  */
6057 > #ifdef __cplusplus
6058 > extern "C"
6059 > #endif
6060 > /* We use char because int might match the return type of a gcc2
6061 >   builtin and then its argument prototype would still apply.  */
6062 > char inflateEnd ();
6063 > #ifdef FC_DUMMY_MAIN
6064 > #ifndef FC_DUMMY_MAIN_EQ_F77
6065 > #  ifdef __cplusplus
6066 >     extern "C"
6067 > #  endif
6068 >   int FC_DUMMY_MAIN() { return 1; }
6069 > #endif
6070 > #endif
6071 > int
6072 > main ()
6073 > {
6074 > inflateEnd ();
6075 >  ;
6076 >  return 0;
6077 > }
6078 > _ACEOF
6079 > rm -f conftest.$ac_objext conftest$ac_exeext
6080 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6081 >  (eval $ac_link) 2>conftest.er1
6082 >  ac_status=$?
6083 >  grep -v '^ *+' conftest.er1 >conftest.err
6084 >  rm -f conftest.er1
6085 >  cat conftest.err >&5
6086 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6087 >  (exit $ac_status); } &&
6088 >         { ac_try='test -z "$ac_c_werror_flag"
6089 >                         || test ! -s conftest.err'
6090 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6091 >  (eval $ac_try) 2>&5
6092 >  ac_status=$?
6093 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6094 >  (exit $ac_status); }; } &&
6095 >         { ac_try='test -s conftest$ac_exeext'
6096 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6097 >  (eval $ac_try) 2>&5
6098 >  ac_status=$?
6099 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6100 >  (exit $ac_status); }; }; then
6101 >  ac_cv_lib_z_inflateEnd=yes
6102 > else
6103 >  echo "$as_me: failed program was:" >&5
6104 > sed 's/^/| /' conftest.$ac_ext >&5
6105 >
6106 > ac_cv_lib_z_inflateEnd=no
6107 > fi
6108 > rm -f conftest.err conftest.$ac_objext \
6109 >      conftest$ac_exeext conftest.$ac_ext
6110 > LIBS=$ac_check_lib_save_LIBS
6111 > fi
6112 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6113 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6114 > if test $ac_cv_lib_z_inflateEnd = yes; then
6115 >  cat >>confdefs.h <<_ACEOF
6116 > #define HAVE_LIBZ 1
6117 > _ACEOF
6118 >
6119 >  LIBS="-lz $LIBS"
6120 >
6121 > fi
6122 >
6123 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6124 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6125 >                echo "$as_me:$LINENO: result: ok" >&5
6126 > echo "${ECHO_T}ok" >&6
6127 >        else
6128 >                #
6129 >                # If either header or library was not found, revert and bomb
6130 >                #
6131 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6132 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6133 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6134 >                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6135 >                echo "$as_me:$LINENO: result: failed" >&5
6136 > echo "${ECHO_T}failed" >&6
6137 >                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
6138 > echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
6139 >   { (exit 1); exit 1; }; }
6140 >        fi
6141 > fi
6142 >
6143 >
6144 >
6145 > # Check whether --with-fftw or --without-fftw was given.
6146 > if test "${with_fftw+set}" = set; then
6147 >  withval="$with_fftw"
6148 >
6149 > else
6150 >  with_fftw=yes
6151 > fi;
6152 > if test "$with_fftw" = "no"; then
6153 >
6154 > cat >>confdefs.h <<\_ACEOF
6155 > #define WITHOUT_FFTW
6156 > _ACEOF
6157 >
6158 > fi
6159 > if test "$with_fftw" = "yes"; then
6160 >  sizeof_real=8
6161 >
6162 >
6163 > if test -z "$ac_fftw_firstname"; then
6164 >
6165 > sizeof_real=$sizeof_real
6166 > if test $sizeof_real = 8; then
6167 >  prec="double"
6168 >  fftwcheckprefix=d
6169 > else
6170 >  prec="single"
6171 >  fftwcheckprefix=s
6172 > fi
6173 >
6174 > xfftwname=${fftwcheckprefix}fftw3
6175 >
6176 > ok="no"
6177 > # check header doesn't work, since we must use mpicc to get includes,
6178 > # we cant trust cpp.
6179 > echo "$as_me:$LINENO: checking for $xfftwname.h" >&5
6180 > echo $ECHO_N "checking for $xfftwname.h... $ECHO_C" >&6
6181 > cat >conftest.$ac_ext <<_ACEOF
6182 > /* confdefs.h.  */
6183 > _ACEOF
6184 > cat confdefs.h >>conftest.$ac_ext
6185 > cat >>conftest.$ac_ext <<_ACEOF
6186 > /* end confdefs.h.  */
6187 > #include <$xfftwname.h>
6188 > #ifdef FC_DUMMY_MAIN
6189 > #ifndef FC_DUMMY_MAIN_EQ_F77
6190 > #  ifdef __cplusplus
6191 >     extern "C"
6192 > #  endif
6193 >   int FC_DUMMY_MAIN() { return 1; }
6194 > #endif
6195 > #endif
6196 > int
6197 > main ()
6198 > {
6199 >
6200 >  ;
6201 >  return 0;
6202 > }
6203 > _ACEOF
6204 > rm -f conftest.$ac_objext
6205 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6206 >  (eval $ac_compile) 2>conftest.er1
6207 >  ac_status=$?
6208 >  grep -v '^ *+' conftest.er1 >conftest.err
6209 >  rm -f conftest.er1
6210 >  cat conftest.err >&5
6211 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6212 >  (exit $ac_status); } &&
6213 >         { ac_try='test -z "$ac_c_werror_flag"
6214 >                         || test ! -s conftest.err'
6215 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6216 >  (eval $ac_try) 2>&5
6217 >  ac_status=$?
6218 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6219 >  (exit $ac_status); }; } &&
6220 >         { ac_try='test -s conftest.$ac_objext'
6221 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6222 >  (eval $ac_try) 2>&5
6223 >  ac_status=$?
6224 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6225 >  (exit $ac_status); }; }; then
6226 >
6227 > fftwname=$xfftwname
6228 > echo "$as_me:$LINENO: result: yes" >&5
6229 > echo "${ECHO_T}yes" >&6
6230 >
6231 > else
6232 >  echo "$as_me: failed program was:" >&5
6233 > sed 's/^/| /' conftest.$ac_ext >&5
6234 >
6235 > echo "$as_me:$LINENO: result: no" >&5
6236 > echo "${ECHO_T}no" >&6
6237 > fi
6238 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6239 >
6240 > # fftwname was set if we found a header
6241 >
6242 > if test -n "$fftwname"; then
6243 > # we cannot run the code since an MPI program might not be allowed
6244 > # on a login node of a supercomputer
6245 > cat >conftest.$ac_ext <<_ACEOF
6246 > /* confdefs.h.  */
6247 > _ACEOF
6248 > cat confdefs.h >>conftest.$ac_ext
6249 > cat >>conftest.$ac_ext <<_ACEOF
6250 > /* end confdefs.h.  */
6251 > #include <$fftwname.h>
6252 > #ifdef FC_DUMMY_MAIN
6253 > #ifndef FC_DUMMY_MAIN_EQ_F77
6254 > #  ifdef __cplusplus
6255 >     extern "C"
6256 > #  endif
6257 >   int FC_DUMMY_MAIN() { return 1; }
6258 > #endif
6259 > #endif
6260 > int
6261 > main ()
6262 > {
6263 > int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6264 >  ;
6265 >  return 0;
6266 > }
6267 > _ACEOF
6268 > rm -f conftest.$ac_objext
6269 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6270 >  (eval $ac_compile) 2>conftest.er1
6271 >  ac_status=$?
6272 >  grep -v '^ *+' conftest.er1 >conftest.err
6273 >  rm -f conftest.er1
6274 >  cat conftest.err >&5
6275 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6276 >  (exit $ac_status); } &&
6277 >         { ac_try='test -z "$ac_c_werror_flag"
6278 >                         || test ! -s conftest.err'
6279 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6280 >  (eval $ac_try) 2>&5
6281 >  ac_status=$?
6282 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6283 >  (exit $ac_status); }; } &&
6284 >         { ac_try='test -s conftest.$ac_objext'
6285 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6286 >  (eval $ac_try) 2>&5
6287 >  ac_status=$?
6288 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6289 >  (exit $ac_status); }; }; then
6290 >
6291 > ok=yes
6292 > usedprefix=$fftwcheckprefix
6293 >
6294 > else
6295 >  echo "$as_me: failed program was:" >&5
6296 > sed 's/^/| /' conftest.$ac_ext >&5
6297 >
6298 > ok=no
6299 > fi
6300 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6301 > fi
6302 >
6303 > if test "$ok" != "yes"; then
6304 >  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6305 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6306 >  cat >conftest.$ac_ext <<_ACEOF
6307 > /* confdefs.h.  */
6308 > _ACEOF
6309 > cat confdefs.h >>conftest.$ac_ext
6310 > cat >>conftest.$ac_ext <<_ACEOF
6311 > /* end confdefs.h.  */
6312 > #include <fftw3.h>
6313 > #ifdef FC_DUMMY_MAIN
6314 > #ifndef FC_DUMMY_MAIN_EQ_F77
6315 > #  ifdef __cplusplus
6316 >     extern "C"
6317 > #  endif
6318 >   int FC_DUMMY_MAIN() { return 1; }
6319 > #endif
6320 > #endif
6321 > int
6322 > main ()
6323 > {
6324 >
6325 >  ;
6326 >  return 0;
6327 > }
6328 > _ACEOF
6329 > rm -f conftest.$ac_objext
6330 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6331 >  (eval $ac_compile) 2>conftest.er1
6332 >  ac_status=$?
6333 >  grep -v '^ *+' conftest.er1 >conftest.err
6334 >  rm -f conftest.er1
6335 >  cat conftest.err >&5
6336 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6337 >  (exit $ac_status); } &&
6338 >         { ac_try='test -z "$ac_c_werror_flag"
6339 >                         || test ! -s conftest.err'
6340 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6341 >  (eval $ac_try) 2>&5
6342 >  ac_status=$?
6343 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6344 >  (exit $ac_status); }; } &&
6345 >         { ac_try='test -s conftest.$ac_objext'
6346 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6347 >  (eval $ac_try) 2>&5
6348 >  ac_status=$?
6349 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6350 >  (exit $ac_status); }; }; then
6351 >  echo "$as_me:$LINENO: result: yes" >&5
6352 > echo "${ECHO_T}yes" >&6
6353 > else
6354 >  echo "$as_me: failed program was:" >&5
6355 > sed 's/^/| /' conftest.$ac_ext >&5
6356 >
6357 >
6358 > echo "$as_me:$LINENO: result: no" >&5
6359 > echo "${ECHO_T}no" >&6
6360 > { { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6361 > Do you have $prec precision FFTW installed? If you are using packages,
6362 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6363 > software at www.fftw.org.
6364 > If you compiled FFTW yourself:
6365 > Note that the default FFTW setup is double precision.  If you want MPI support,
6366 > use --with-mpi. It is a good idea to install both single & double.
6367 > If you have installed FFTW in a non-standard location, you should
6368 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6369 > variables before running configure.
6370 > That is also necessary to do if your compiler doesn't search
6371 > /usr/local/include and /usr/local/lib by default." >&5
6372 > echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6373 > Do you have $prec precision FFTW installed? If you are using packages,
6374 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6375 > software at www.fftw.org.
6376 > If you compiled FFTW yourself:
6377 > Note that the default FFTW setup is double precision.  If you want MPI support,
6378 > use --with-mpi. It is a good idea to install both single & double.
6379 > If you have installed FFTW in a non-standard location, you should
6380 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6381 > variables before running configure.
6382 > That is also necessary to do if your compiler doesn't search
6383 > /usr/local/include and /usr/local/lib by default." >&2;}
6384 >   { (exit 1); exit 1; }; }
6385 >
6386 > fi
6387 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6388 > cat >conftest.$ac_ext <<_ACEOF
6389 > /* confdefs.h.  */
6390 > _ACEOF
6391 > cat confdefs.h >>conftest.$ac_ext
6392 > cat >>conftest.$ac_ext <<_ACEOF
6393 > /* end confdefs.h.  */
6394 > #include <fftw3.h>
6395 > #ifdef FC_DUMMY_MAIN
6396 > #ifndef FC_DUMMY_MAIN_EQ_F77
6397 > #  ifdef __cplusplus
6398 >     extern "C"
6399 > #  endif
6400 >   int FC_DUMMY_MAIN() { return 1; }
6401 > #endif
6402 > #endif
6403 > int
6404 > main ()
6405 > {
6406 > int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6407 >  ;
6408 >  return 0;
6409 > }
6410 > _ACEOF
6411 > rm -f conftest.$ac_objext
6412 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6413 >  (eval $ac_compile) 2>conftest.er1
6414 >  ac_status=$?
6415 >  grep -v '^ *+' conftest.er1 >conftest.err
6416 >  rm -f conftest.er1
6417 >  cat conftest.err >&5
6418 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6419 >  (exit $ac_status); } &&
6420 >         { ac_try='test -z "$ac_c_werror_flag"
6421 >                         || test ! -s conftest.err'
6422 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6423 >  (eval $ac_try) 2>&5
6424 >  ac_status=$?
6425 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6426 >  (exit $ac_status); }; } &&
6427 >         { ac_try='test -s conftest.$ac_objext'
6428 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6429 >  (eval $ac_try) 2>&5
6430 >  ac_status=$?
6431 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6432 >  (exit $ac_status); }; }; then
6433 >
6434 > usedprefix=""
6435 > fftwname=fftw3
6436 >
6437 > else
6438 >  echo "$as_me: failed program was:" >&5
6439 > sed 's/^/| /' conftest.$ac_ext >&5
6440 >
6441 >
6442 > { { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6443 > Do you have $prec precision FFTW installed? If you are using packages,
6444 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6445 > software at www.fftw.org.
6446 > If you compiled FFTW yourself:
6447 > Note that the default FFTW setup is double precision.  If you want MPI support,
6448 > use --with-mpi. It is a good idea to install both single & double.
6449 > If you have installed FFTW in a non-standard location, you should
6450 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6451 > variables before running configure.
6452 > That is also necessary to do if your compiler doesn't search
6453 > /usr/local/include and /usr/local/lib by default." >&5
6454 > echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3.h
6455 > Do you have $prec precision FFTW installed? If you are using packages,
6456 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6457 > software at www.fftw.org.
6458 > If you compiled FFTW yourself:
6459 > Note that the default FFTW setup is double precision.  If you want MPI support,
6460 > use --with-mpi. It is a good idea to install both single & double.
6461 > If you have installed FFTW in a non-standard location, you should
6462 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6463 > variables before running configure.
6464 > That is also necessary to do if your compiler doesn't search
6465 > /usr/local/include and /usr/local/lib by default." >&2;}
6466 >   { (exit 1); exit 1; }; }
6467 > fi
6468 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6469 > fi
6470 >
6471 >
6472 > as_ac_Lib=`echo "ac_cv_lib_$fftwname''_main" | $as_tr_sh`
6473 > echo "$as_me:$LINENO: checking for main in -l$fftwname" >&5
6474 > echo $ECHO_N "checking for main in -l$fftwname... $ECHO_C" >&6
6475 > if eval "test \"\${$as_ac_Lib+set}\" = set"; then
6476 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6477 > else
6478 >  ac_check_lib_save_LIBS=$LIBS
6479 > LIBS="-l$fftwname  $LIBS"
6480 > cat >conftest.$ac_ext <<_ACEOF
6481 > /* confdefs.h.  */
6482 > _ACEOF
6483 > cat confdefs.h >>conftest.$ac_ext
6484 > cat >>conftest.$ac_ext <<_ACEOF
6485 > /* end confdefs.h.  */
6486 >
6487 >
6488 > #ifdef FC_DUMMY_MAIN
6489 > #ifndef FC_DUMMY_MAIN_EQ_F77
6490 > #  ifdef __cplusplus
6491 >     extern "C"
6492 > #  endif
6493 >   int FC_DUMMY_MAIN() { return 1; }
6494 > #endif
6495 > #endif
6496 > int
6497 > main ()
6498 > {
6499 > main ();
6500 >  ;
6501 >  return 0;
6502 > }
6503 > _ACEOF
6504 > rm -f conftest.$ac_objext conftest$ac_exeext
6505 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6506 >  (eval $ac_link) 2>conftest.er1
6507 >  ac_status=$?
6508 >  grep -v '^ *+' conftest.er1 >conftest.err
6509 >  rm -f conftest.er1
6510 >  cat conftest.err >&5
6511 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6512 >  (exit $ac_status); } &&
6513 >         { ac_try='test -z "$ac_c_werror_flag"
6514 >                         || test ! -s conftest.err'
6515 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6516 >  (eval $ac_try) 2>&5
6517 >  ac_status=$?
6518 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6519 >  (exit $ac_status); }; } &&
6520 >         { ac_try='test -s conftest$ac_exeext'
6521 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6522 >  (eval $ac_try) 2>&5
6523 >  ac_status=$?
6524 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6525 >  (exit $ac_status); }; }; then
6526 >  eval "$as_ac_Lib=yes"
6527 > else
6528 >  echo "$as_me: failed program was:" >&5
6529 > sed 's/^/| /' conftest.$ac_ext >&5
6530 >
6531 > eval "$as_ac_Lib=no"
6532 > fi
6533 > rm -f conftest.err conftest.$ac_objext \
6534 >      conftest$ac_exeext conftest.$ac_ext
6535 > LIBS=$ac_check_lib_save_LIBS
6536 > fi
6537 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Lib'}'`" >&5
6538 > echo "${ECHO_T}`eval echo '${'$as_ac_Lib'}'`" >&6
6539 > if test `eval echo '${'$as_ac_Lib'}'` = yes; then
6540 >  cat >>confdefs.h <<_ACEOF
6541 > #define `echo "HAVE_LIB$fftwname" | $as_tr_cpp` 1
6542 > _ACEOF
6543 >
6544 >  LIBS="-l$fftwname $LIBS"
6545 >
6546 > else
6547 >  { { echo "$as_me:$LINENO: error: Can't find a library to match the $fftwname header" >&5
6548 > echo "$as_me: error: Can't find a library to match the $fftwname header" >&2;}
6549 >   { (exit 1); exit 1; }; }
6550 > fi
6551 >
6552 > ac_fftw_savedprefix=$usedprefix
6553 > ac_fftw_firstname=$fftwname
6554 >
6555 > else
6556 >
6557 > fftwname=${ac_fftw_savedprefix}fftw3
6558 > echo "$as_me:$LINENO: checking for $fftwname.h" >&5
6559 > echo $ECHO_N "checking for $fftwname.h... $ECHO_C" >&6
6560 > cat >conftest.$ac_ext <<_ACEOF
6561 > /* confdefs.h.  */
6562 > _ACEOF
6563 > cat confdefs.h >>conftest.$ac_ext
6564 > cat >>conftest.$ac_ext <<_ACEOF
6565 > /* end confdefs.h.  */
6566 > #include <$fftwname.h>
6567 > #ifdef FC_DUMMY_MAIN
6568 > #ifndef FC_DUMMY_MAIN_EQ_F77
6569 > #  ifdef __cplusplus
6570 >     extern "C"
6571 > #  endif
6572 >   int FC_DUMMY_MAIN() { return 1; }
6573 > #endif
6574 > #endif
6575 > int
6576 > main ()
6577 > {
6578 >
6579 >  ;
6580 >  return 0;
6581 > }
6582 > _ACEOF
6583 > rm -f conftest.$ac_objext
6584 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6585 >  (eval $ac_compile) 2>conftest.er1
6586 >  ac_status=$?
6587 >  grep -v '^ *+' conftest.er1 >conftest.err
6588 >  rm -f conftest.er1
6589 >  cat conftest.err >&5
6590 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6591 >  (exit $ac_status); } &&
6592 >         { ac_try='test -z "$ac_c_werror_flag"
6593 >                         || test ! -s conftest.err'
6594 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6595 >  (eval $ac_try) 2>&5
6596 >  ac_status=$?
6597 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6598 >  (exit $ac_status); }; } &&
6599 >         { ac_try='test -s conftest.$ac_objext'
6600 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6601 >  (eval $ac_try) 2>&5
6602 >  ac_status=$?
6603 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6604 >  (exit $ac_status); }; }; then
6605 >  echo "$as_me:$LINENO: result: yes" >&5
6606 > echo "${ECHO_T}yes" >&6
6607 > LIBS="-l$fftwname $LIBS"
6608 > cat >conftest.$ac_ext <<_ACEOF
6609 > /* confdefs.h.  */
6610 > _ACEOF
6611 > cat confdefs.h >>conftest.$ac_ext
6612 > cat >>conftest.$ac_ext <<_ACEOF
6613 > /* end confdefs.h.  */
6614 >
6615 >
6616 > #ifdef FC_DUMMY_MAIN
6617 > #ifndef FC_DUMMY_MAIN_EQ_F77
6618 > #  ifdef __cplusplus
6619 >     extern "C"
6620 > #  endif
6621 >   int FC_DUMMY_MAIN() { return 1; }
6622 > #endif
6623 > #endif
6624 > int
6625 > main ()
6626 > {
6627 > main ();
6628 >  ;
6629 >  return 0;
6630 > }
6631 > _ACEOF
6632 > rm -f conftest.$ac_objext conftest$ac_exeext
6633 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6634 >  (eval $ac_link) 2>conftest.er1
6635 >  ac_status=$?
6636 >  grep -v '^ *+' conftest.er1 >conftest.err
6637 >  rm -f conftest.er1
6638 >  cat conftest.err >&5
6639 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6640 >  (exit $ac_status); } &&
6641 >         { ac_try='test -z "$ac_c_werror_flag"
6642 >                         || test ! -s conftest.err'
6643 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6644 >  (eval $ac_try) 2>&5
6645 >  ac_status=$?
6646 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6647 >  (exit $ac_status); }; } &&
6648 >         { ac_try='test -s conftest$ac_exeext'
6649 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6650 >  (eval $ac_try) 2>&5
6651 >  ac_status=$?
6652 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6653 >  (exit $ac_status); }; }; then
6654 >  :
6655 > else
6656 >  echo "$as_me: failed program was:" >&5
6657 > sed 's/^/| /' conftest.$ac_ext >&5
6658 >
6659 > fi
6660 > rm -f conftest.err conftest.$ac_objext \
6661 >      conftest$ac_exeext conftest.$ac_ext
6662 > else
6663 >  echo "$as_me: failed program was:" >&5
6664 > sed 's/^/| /' conftest.$ac_ext >&5
6665 >
6666 >
6667 > echo "$as_me:$LINENO: result: no" >&5
6668 > echo "${ECHO_T}no" >&6
6669 > { { echo "$as_me:$LINENO: error: Cant find $fftwname.h header. Make sure all your
6670 > fftw prefixes match - we already use $ac_fftw_firstname.h" >&5
6671 > echo "$as_me: error: Cant find $fftwname.h header. Make sure all your
6672 > fftw prefixes match - we already use $ac_fftw_firstname.h" >&2;}
6673 >   { (exit 1); exit 1; }; }
6674 >
6675 > fi
6676 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6677 >
6678 > fi
6679 >
6680 >
6681 >
6682 >  if test "$with_mpi" = "yes"; then
6683 >
6684 > if test -z "$ac_fftw_firstname"; then
6685 >
6686 > sizeof_real=$sizeof_real
6687 > if test $sizeof_real = 8; then
6688 >  prec="double"
6689 >  fftwcheckprefix=d
6690 > else
6691 >  prec="single"
6692 >  fftwcheckprefix=s
6693 > fi
6694 >
6695 > xfftwname=${fftwcheckprefix}fftw3_mpi
6696 >
6697 > ok="no"
6698 > # check header doesn't work, since we must use mpicc to get includes,
6699 > # we cant trust cpp.
6700 > echo "$as_me:$LINENO: checking for $xfftwname.h" >&5
6701 > echo $ECHO_N "checking for $xfftwname.h... $ECHO_C" >&6
6702 > cat >conftest.$ac_ext <<_ACEOF
6703 > /* confdefs.h.  */
6704 > _ACEOF
6705 > cat confdefs.h >>conftest.$ac_ext
6706 > cat >>conftest.$ac_ext <<_ACEOF
6707 > /* end confdefs.h.  */
6708 > #include <$xfftwname.h>
6709 > #ifdef FC_DUMMY_MAIN
6710 > #ifndef FC_DUMMY_MAIN_EQ_F77
6711 > #  ifdef __cplusplus
6712 >     extern "C"
6713 > #  endif
6714 >   int FC_DUMMY_MAIN() { return 1; }
6715 > #endif
6716 > #endif
6717 > int
6718 > main ()
6719 > {
6720 >
6721 >  ;
6722 >  return 0;
6723 > }
6724 > _ACEOF
6725 > rm -f conftest.$ac_objext
6726 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6727 >  (eval $ac_compile) 2>conftest.er1
6728 >  ac_status=$?
6729 >  grep -v '^ *+' conftest.er1 >conftest.err
6730 >  rm -f conftest.er1
6731 >  cat conftest.err >&5
6732 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6733 >  (exit $ac_status); } &&
6734 >         { ac_try='test -z "$ac_c_werror_flag"
6735 >                         || test ! -s conftest.err'
6736 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6737 >  (eval $ac_try) 2>&5
6738 >  ac_status=$?
6739 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6740 >  (exit $ac_status); }; } &&
6741 >         { ac_try='test -s conftest.$ac_objext'
6742 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6743 >  (eval $ac_try) 2>&5
6744 >  ac_status=$?
6745 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6746 >  (exit $ac_status); }; }; then
6747 >
6748 > fftwname=$xfftwname
6749 > echo "$as_me:$LINENO: result: yes" >&5
6750 > echo "${ECHO_T}yes" >&6
6751 >
6752 > else
6753 >  echo "$as_me: failed program was:" >&5
6754 > sed 's/^/| /' conftest.$ac_ext >&5
6755 >
6756 > echo "$as_me:$LINENO: result: no" >&5
6757 > echo "${ECHO_T}no" >&6
6758 > fi
6759 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6760 >
6761 > # fftwname was set if we found a header
6762 >
6763 > if test -n "$fftwname"; then
6764 > # we cannot run the code since an MPI program might not be allowed
6765 > # on a login node of a supercomputer
6766 > cat >conftest.$ac_ext <<_ACEOF
6767 > /* confdefs.h.  */
6768 > _ACEOF
6769 > cat confdefs.h >>conftest.$ac_ext
6770 > cat >>conftest.$ac_ext <<_ACEOF
6771 > /* end confdefs.h.  */
6772 > #include <$fftwname.h>
6773 > #ifdef FC_DUMMY_MAIN
6774 > #ifndef FC_DUMMY_MAIN_EQ_F77
6775 > #  ifdef __cplusplus
6776 >     extern "C"
6777 > #  endif
6778 >   int FC_DUMMY_MAIN() { return 1; }
6779 > #endif
6780 > #endif
6781 > int
6782 > main ()
6783 > {
6784 > int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6785 >  ;
6786 >  return 0;
6787 > }
6788 > _ACEOF
6789 > rm -f conftest.$ac_objext
6790 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6791 >  (eval $ac_compile) 2>conftest.er1
6792 >  ac_status=$?
6793 >  grep -v '^ *+' conftest.er1 >conftest.err
6794 >  rm -f conftest.er1
6795 >  cat conftest.err >&5
6796 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6797 >  (exit $ac_status); } &&
6798 >         { ac_try='test -z "$ac_c_werror_flag"
6799 >                         || test ! -s conftest.err'
6800 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6801 >  (eval $ac_try) 2>&5
6802 >  ac_status=$?
6803 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6804 >  (exit $ac_status); }; } &&
6805 >         { ac_try='test -s conftest.$ac_objext'
6806 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6807 >  (eval $ac_try) 2>&5
6808 >  ac_status=$?
6809 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6810 >  (exit $ac_status); }; }; then
6811 >
6812 > ok=yes
6813 > usedprefix=$fftwcheckprefix
6814 >
6815 > else
6816 >  echo "$as_me: failed program was:" >&5
6817 > sed 's/^/| /' conftest.$ac_ext >&5
6818 >
6819 > ok=no
6820 > fi
6821 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6822 > fi
6823 >
6824 > if test "$ok" != "yes"; then
6825 >  echo "$as_me:$LINENO: checking for fftw3_mpi.h" >&5
6826 > echo $ECHO_N "checking for fftw3_mpi.h... $ECHO_C" >&6
6827 >  cat >conftest.$ac_ext <<_ACEOF
6828 > /* confdefs.h.  */
6829 > _ACEOF
6830 > cat confdefs.h >>conftest.$ac_ext
6831 > cat >>conftest.$ac_ext <<_ACEOF
6832 > /* end confdefs.h.  */
6833 > #include <fftw3_mpi.h>
6834 > #ifdef FC_DUMMY_MAIN
6835 > #ifndef FC_DUMMY_MAIN_EQ_F77
6836 > #  ifdef __cplusplus
6837 >     extern "C"
6838 > #  endif
6839 >   int FC_DUMMY_MAIN() { return 1; }
6840 > #endif
6841 > #endif
6842 > int
6843 > main ()
6844 > {
6845 >
6846 >  ;
6847 >  return 0;
6848 > }
6849 > _ACEOF
6850 > rm -f conftest.$ac_objext
6851 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6852 >  (eval $ac_compile) 2>conftest.er1
6853 >  ac_status=$?
6854 >  grep -v '^ *+' conftest.er1 >conftest.err
6855 >  rm -f conftest.er1
6856 >  cat conftest.err >&5
6857 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6858 >  (exit $ac_status); } &&
6859 >         { ac_try='test -z "$ac_c_werror_flag"
6860 >                         || test ! -s conftest.err'
6861 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6862 >  (eval $ac_try) 2>&5
6863 >  ac_status=$?
6864 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6865 >  (exit $ac_status); }; } &&
6866 >         { ac_try='test -s conftest.$ac_objext'
6867 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6868 >  (eval $ac_try) 2>&5
6869 >  ac_status=$?
6870 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6871 >  (exit $ac_status); }; }; then
6872 >  echo "$as_me:$LINENO: result: yes" >&5
6873 > echo "${ECHO_T}yes" >&6
6874 > else
6875 >  echo "$as_me: failed program was:" >&5
6876 > sed 's/^/| /' conftest.$ac_ext >&5
6877 >
6878 >
6879 > echo "$as_me:$LINENO: result: no" >&5
6880 > echo "${ECHO_T}no" >&6
6881 > { { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6882 > Do you have $prec precision FFTW installed? If you are using packages,
6883 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6884 > software at www.fftw.org.
6885 > If you compiled FFTW yourself:
6886 > Note that the default FFTW setup is double precision.  If you want MPI support,
6887 > use --with-mpi. It is a good idea to install both single & double.
6888 > If you have installed FFTW in a non-standard location, you should
6889 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6890 > variables before running configure.
6891 > That is also necessary to do if your compiler doesn't search
6892 > /usr/local/include and /usr/local/lib by default." >&5
6893 > echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6894 > Do you have $prec precision FFTW installed? If you are using packages,
6895 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6896 > software at www.fftw.org.
6897 > If you compiled FFTW yourself:
6898 > Note that the default FFTW setup is double precision.  If you want MPI support,
6899 > use --with-mpi. It is a good idea to install both single & double.
6900 > If you have installed FFTW in a non-standard location, you should
6901 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6902 > variables before running configure.
6903 > That is also necessary to do if your compiler doesn't search
6904 > /usr/local/include and /usr/local/lib by default." >&2;}
6905 >   { (exit 1); exit 1; }; }
6906 >
6907 > fi
6908 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6909 > cat >conftest.$ac_ext <<_ACEOF
6910 > /* confdefs.h.  */
6911 > _ACEOF
6912 > cat confdefs.h >>conftest.$ac_ext
6913 > cat >>conftest.$ac_ext <<_ACEOF
6914 > /* end confdefs.h.  */
6915 > #include <fftw3_mpi.h>
6916 > #ifdef FC_DUMMY_MAIN
6917 > #ifndef FC_DUMMY_MAIN_EQ_F77
6918 > #  ifdef __cplusplus
6919 >     extern "C"
6920 > #  endif
6921 >   int FC_DUMMY_MAIN() { return 1; }
6922 > #endif
6923 > #endif
6924 > int
6925 > main ()
6926 > {
6927 > int _array_ [1 - 2 * !((sizeof(fftw_real)) == $sizeof_real)];
6928 >  ;
6929 >  return 0;
6930 > }
6931 > _ACEOF
6932 > rm -f conftest.$ac_objext
6933 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6934 >  (eval $ac_compile) 2>conftest.er1
6935 >  ac_status=$?
6936 >  grep -v '^ *+' conftest.er1 >conftest.err
6937 >  rm -f conftest.er1
6938 >  cat conftest.err >&5
6939 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6940 >  (exit $ac_status); } &&
6941 >         { ac_try='test -z "$ac_c_werror_flag"
6942 >                         || test ! -s conftest.err'
6943 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6944 >  (eval $ac_try) 2>&5
6945 >  ac_status=$?
6946 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6947 >  (exit $ac_status); }; } &&
6948 >         { ac_try='test -s conftest.$ac_objext'
6949 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6950 >  (eval $ac_try) 2>&5
6951 >  ac_status=$?
6952 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6953 >  (exit $ac_status); }; }; then
6954 >
6955 > usedprefix=""
6956 > fftwname=fftw3_mpi
6957 >
6958 > else
6959 >  echo "$as_me: failed program was:" >&5
6960 > sed 's/^/| /' conftest.$ac_ext >&5
6961 >
6962 >
6963 > { { echo "$as_me:$LINENO: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6964 > Do you have $prec precision FFTW installed? If you are using packages,
6965 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6966 > software at www.fftw.org.
6967 > If you compiled FFTW yourself:
6968 > Note that the default FFTW setup is double precision.  If you want MPI support,
6969 > use --with-mpi. It is a good idea to install both single & double.
6970 > If you have installed FFTW in a non-standard location, you should
6971 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6972 > variables before running configure.
6973 > That is also necessary to do if your compiler doesn't search
6974 > /usr/local/include and /usr/local/lib by default." >&5
6975 > echo "$as_me: error: Cannot find any $prec precision $xfftwname.h or fftw3_mpi.h
6976 > Do you have $prec precision FFTW installed? If you are using packages,
6977 > note that you also need fftw-devel to use FFTW with OOPSE. You can find the
6978 > software at www.fftw.org.
6979 > If you compiled FFTW yourself:
6980 > Note that the default FFTW setup is double precision.  If you want MPI support,
6981 > use --with-mpi. It is a good idea to install both single & double.
6982 > If you have installed FFTW in a non-standard location, you should
6983 > provide the correct paths in the CPPFLAGS and LDFLAGS environment
6984 > variables before running configure.
6985 > That is also necessary to do if your compiler doesn't search
6986 > /usr/local/include and /usr/local/lib by default." >&2;}
6987 >   { (exit 1); exit 1; }; }
6988 > fi
6989 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6990 > fi
6991 >
6992 >
6993 > as_ac_Lib=`echo "ac_cv_lib_$fftwname''_main" | $as_tr_sh`
6994 > echo "$as_me:$LINENO: checking for main in -l$fftwname" >&5
6995 > echo $ECHO_N "checking for main in -l$fftwname... $ECHO_C" >&6
6996 > if eval "test \"\${$as_ac_Lib+set}\" = set"; then
6997 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6998 > else
6999 >  ac_check_lib_save_LIBS=$LIBS
7000 > LIBS="-l$fftwname  $LIBS"
7001 > cat >conftest.$ac_ext <<_ACEOF
7002 > /* confdefs.h.  */
7003 > _ACEOF
7004 > cat confdefs.h >>conftest.$ac_ext
7005 > cat >>conftest.$ac_ext <<_ACEOF
7006 > /* end confdefs.h.  */
7007 >
7008 >
7009 > #ifdef FC_DUMMY_MAIN
7010 > #ifndef FC_DUMMY_MAIN_EQ_F77
7011 > #  ifdef __cplusplus
7012 >     extern "C"
7013 > #  endif
7014 >   int FC_DUMMY_MAIN() { return 1; }
7015 > #endif
7016 > #endif
7017 > int
7018 > main ()
7019 > {
7020 > main ();
7021 >  ;
7022 >  return 0;
7023 > }
7024 > _ACEOF
7025 > rm -f conftest.$ac_objext conftest$ac_exeext
7026 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7027 >  (eval $ac_link) 2>conftest.er1
7028 >  ac_status=$?
7029 >  grep -v '^ *+' conftest.er1 >conftest.err
7030 >  rm -f conftest.er1
7031 >  cat conftest.err >&5
7032 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7033 >  (exit $ac_status); } &&
7034 >         { ac_try='test -z "$ac_c_werror_flag"
7035 >                         || test ! -s conftest.err'
7036 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7037 >  (eval $ac_try) 2>&5
7038 >  ac_status=$?
7039 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7040 >  (exit $ac_status); }; } &&
7041 >         { ac_try='test -s conftest$ac_exeext'
7042 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7043 >  (eval $ac_try) 2>&5
7044 >  ac_status=$?
7045 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7046 >  (exit $ac_status); }; }; then
7047 >  eval "$as_ac_Lib=yes"
7048 > else
7049 >  echo "$as_me: failed program was:" >&5
7050 > sed 's/^/| /' conftest.$ac_ext >&5
7051 >
7052 > eval "$as_ac_Lib=no"
7053 > fi
7054 > rm -f conftest.err conftest.$ac_objext \
7055 >      conftest$ac_exeext conftest.$ac_ext
7056 > LIBS=$ac_check_lib_save_LIBS
7057 > fi
7058 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Lib'}'`" >&5
7059 > echo "${ECHO_T}`eval echo '${'$as_ac_Lib'}'`" >&6
7060 > if test `eval echo '${'$as_ac_Lib'}'` = yes; then
7061 >  cat >>confdefs.h <<_ACEOF
7062 > #define `echo "HAVE_LIB$fftwname" | $as_tr_cpp` 1
7063 > _ACEOF
7064 >
7065 >  LIBS="-l$fftwname $LIBS"
7066 >
7067 > else
7068 >  { { echo "$as_me:$LINENO: error: Can't find a library to match the $fftwname header" >&5
7069 > echo "$as_me: error: Can't find a library to match the $fftwname header" >&2;}
7070 >   { (exit 1); exit 1; }; }
7071 > fi
7072 >
7073 > ac_fftw_savedprefix=$usedprefix
7074 > ac_fftw_firstname=$fftwname
7075 >
7076 > else
7077 >
7078 > fftwname=${ac_fftw_savedprefix}fftw3_mpi
7079 > echo "$as_me:$LINENO: checking for $fftwname.h" >&5
7080 > echo $ECHO_N "checking for $fftwname.h... $ECHO_C" >&6
7081 > cat >conftest.$ac_ext <<_ACEOF
7082 > /* confdefs.h.  */
7083 > _ACEOF
7084 > cat confdefs.h >>conftest.$ac_ext
7085 > cat >>conftest.$ac_ext <<_ACEOF
7086 > /* end confdefs.h.  */
7087 > #include <$fftwname.h>
7088 > #ifdef FC_DUMMY_MAIN
7089 > #ifndef FC_DUMMY_MAIN_EQ_F77
7090 > #  ifdef __cplusplus
7091 >     extern "C"
7092 > #  endif
7093 >   int FC_DUMMY_MAIN() { return 1; }
7094 > #endif
7095 > #endif
7096 > int
7097 > main ()
7098 > {
7099 >
7100 >  ;
7101 >  return 0;
7102 > }
7103 > _ACEOF
7104 > rm -f conftest.$ac_objext
7105 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7106 >  (eval $ac_compile) 2>conftest.er1
7107 >  ac_status=$?
7108 >  grep -v '^ *+' conftest.er1 >conftest.err
7109 >  rm -f conftest.er1
7110 >  cat conftest.err >&5
7111 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7112 >  (exit $ac_status); } &&
7113 >         { ac_try='test -z "$ac_c_werror_flag"
7114 >                         || test ! -s conftest.err'
7115 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7116 >  (eval $ac_try) 2>&5
7117 >  ac_status=$?
7118 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7119 >  (exit $ac_status); }; } &&
7120 >         { ac_try='test -s conftest.$ac_objext'
7121 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7122 >  (eval $ac_try) 2>&5
7123 >  ac_status=$?
7124 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7125 >  (exit $ac_status); }; }; then
7126 >  echo "$as_me:$LINENO: result: yes" >&5
7127 > echo "${ECHO_T}yes" >&6
7128 > LIBS="-l$fftwname $LIBS"
7129 > cat >conftest.$ac_ext <<_ACEOF
7130 > /* confdefs.h.  */
7131 > _ACEOF
7132 > cat confdefs.h >>conftest.$ac_ext
7133 > cat >>conftest.$ac_ext <<_ACEOF
7134 > /* end confdefs.h.  */
7135 >
7136 >
7137 > #ifdef FC_DUMMY_MAIN
7138 > #ifndef FC_DUMMY_MAIN_EQ_F77
7139 > #  ifdef __cplusplus
7140 >     extern "C"
7141 > #  endif
7142 >   int FC_DUMMY_MAIN() { return 1; }
7143 > #endif
7144 > #endif
7145 > int
7146 > main ()
7147 > {
7148 > main ();
7149 >  ;
7150 >  return 0;
7151 > }
7152 > _ACEOF
7153 > rm -f conftest.$ac_objext conftest$ac_exeext
7154 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7155 >  (eval $ac_link) 2>conftest.er1
7156 >  ac_status=$?
7157 >  grep -v '^ *+' conftest.er1 >conftest.err
7158 >  rm -f conftest.er1
7159 >  cat conftest.err >&5
7160 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7161 >  (exit $ac_status); } &&
7162 >         { ac_try='test -z "$ac_c_werror_flag"
7163 >                         || test ! -s conftest.err'
7164 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7165 >  (eval $ac_try) 2>&5
7166 >  ac_status=$?
7167 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7168 >  (exit $ac_status); }; } &&
7169 >         { ac_try='test -s conftest$ac_exeext'
7170 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7171 >  (eval $ac_try) 2>&5
7172 >  ac_status=$?
7173 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7174 >  (exit $ac_status); }; }; then
7175 >  :
7176 > else
7177 >  echo "$as_me: failed program was:" >&5
7178 > sed 's/^/| /' conftest.$ac_ext >&5
7179 >
7180 > fi
7181 > rm -f conftest.err conftest.$ac_objext \
7182 >      conftest$ac_exeext conftest.$ac_ext
7183 > else
7184 >  echo "$as_me: failed program was:" >&5
7185 > sed 's/^/| /' conftest.$ac_ext >&5
7186 >
7187 >
7188 > echo "$as_me:$LINENO: result: no" >&5
7189 > echo "${ECHO_T}no" >&6
7190 > { { echo "$as_me:$LINENO: error: Cant find $fftwname.h header. Make sure all your
7191 > fftw prefixes match - we already use $ac_fftw_firstname.h" >&5
7192 > echo "$as_me: error: Cant find $fftwname.h header. Make sure all your
7193 > fftw prefixes match - we already use $ac_fftw_firstname.h" >&2;}
7194 >   { (exit 1); exit 1; }; }
7195 >
7196 > fi
7197 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7198 >
7199 > fi
7200 >
7201 >
7202 >  fi
7203 >
7204 >  case ${ac_fftw_savedprefix} in
7205 >   d)
7206 > cat >>confdefs.h <<\_ACEOF
7207 > #define FFTW_NAME_DFFTW
7208 > _ACEOF
7209 > ;;
7210 >   *)
7211 > cat >>confdefs.h <<\_ACEOF
7212 > #define FFTW_NAME_FFTW
7213 > _ACEOF
7214 > ;;
7215 >  esac
7216 > else
7217 >  echo "*******************************************************************"
7218 >  echo "* FFTW libraries and include files are required for computing     *"
7219 >  echo "* undulation spectra with the staticProps program.  If you don't  *"
7220 >  echo "* fftw turned on, OOPSE will still work, but you won't be able to *"
7221 >  echo "* analyze your trajectories for this property.                    *"
7222 >  echo "*******************************************************************"
7223 > fi # end of fftw check
7224 >
7225 > # Checks for header files.
7226 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
7227 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
7228 > if test "${ac_cv_header_stdc+set}" = set; then
7229 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7230 > else
7231 >  cat >conftest.$ac_ext <<_ACEOF
7232 > /* confdefs.h.  */
7233 > _ACEOF
7234 > cat confdefs.h >>conftest.$ac_ext
7235 > cat >>conftest.$ac_ext <<_ACEOF
7236 > /* end confdefs.h.  */
7237 > #include <stdlib.h>
7238 > #include <stdarg.h>
7239 > #include <string.h>
7240 > #include <float.h>
7241 >
7242 > #ifdef FC_DUMMY_MAIN
7243 > #ifndef FC_DUMMY_MAIN_EQ_F77
7244 > #  ifdef __cplusplus
7245 >     extern "C"
7246 > #  endif
7247 >   int FC_DUMMY_MAIN() { return 1; }
7248 > #endif
7249 > #endif
7250 > int
7251 > main ()
7252 > {
7253 >
7254 >  ;
7255 >  return 0;
7256 > }
7257 > _ACEOF
7258 > rm -f conftest.$ac_objext
7259 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7260 >  (eval $ac_compile) 2>conftest.er1
7261 >  ac_status=$?
7262 >  grep -v '^ *+' conftest.er1 >conftest.err
7263 >  rm -f conftest.er1
7264 >  cat conftest.err >&5
7265 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7266 >  (exit $ac_status); } &&
7267 >         { ac_try='test -z "$ac_c_werror_flag"
7268 >                         || test ! -s conftest.err'
7269 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7270 >  (eval $ac_try) 2>&5
7271 >  ac_status=$?
7272 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7273 >  (exit $ac_status); }; } &&
7274 >         { ac_try='test -s conftest.$ac_objext'
7275 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7276 >  (eval $ac_try) 2>&5
7277 >  ac_status=$?
7278 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7279 >  (exit $ac_status); }; }; then
7280 >  ac_cv_header_stdc=yes
7281 > else
7282 >  echo "$as_me: failed program was:" >&5
7283 > sed 's/^/| /' conftest.$ac_ext >&5
7284 >
7285 > ac_cv_header_stdc=no
7286 > fi
7287 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7288 >
7289 > if test $ac_cv_header_stdc = yes; then
7290 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7291 >  cat >conftest.$ac_ext <<_ACEOF
7292 > /* confdefs.h.  */
7293 > _ACEOF
7294 > cat confdefs.h >>conftest.$ac_ext
7295 > cat >>conftest.$ac_ext <<_ACEOF
7296 > /* end confdefs.h.  */
7297 > #include <string.h>
7298 >
7299 > _ACEOF
7300 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7301 >  $EGREP "memchr" >/dev/null 2>&1; then
7302 >  :
7303 > else
7304 >  ac_cv_header_stdc=no
7305 > fi
7306 > rm -f conftest*
7307 >
7308 > fi
7309 >
7310 > if test $ac_cv_header_stdc = yes; then
7311 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7312 >  cat >conftest.$ac_ext <<_ACEOF
7313 > /* confdefs.h.  */
7314 > _ACEOF
7315 > cat confdefs.h >>conftest.$ac_ext
7316 > cat >>conftest.$ac_ext <<_ACEOF
7317 > /* end confdefs.h.  */
7318 > #include <stdlib.h>
7319 >
7320 > _ACEOF
7321 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7322 >  $EGREP "free" >/dev/null 2>&1; then
7323 >  :
7324 > else
7325 >  ac_cv_header_stdc=no
7326 > fi
7327 > rm -f conftest*
7328 >
7329 > fi
7330 >
7331 > if test $ac_cv_header_stdc = yes; then
7332 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7333 >  if test "$cross_compiling" = yes; then
7334 >  :
7335 > else
7336 >  cat >conftest.$ac_ext <<_ACEOF
7337 > /* confdefs.h.  */
7338 > _ACEOF
7339 > cat confdefs.h >>conftest.$ac_ext
7340 > cat >>conftest.$ac_ext <<_ACEOF
7341 > /* end confdefs.h.  */
7342 > #include <ctype.h>
7343 > #if ((' ' & 0x0FF) == 0x020)
7344 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7345 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7346 > #else
7347 > # define ISLOWER(c) \
7348 >                   (('a' <= (c) && (c) <= 'i') \
7349 >                     || ('j' <= (c) && (c) <= 'r') \
7350 >                     || ('s' <= (c) && (c) <= 'z'))
7351 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7352 > #endif
7353 >
7354 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7355 > int
7356 > main ()
7357 > {
7358 >  int i;
7359 >  for (i = 0; i < 256; i++)
7360 >    if (XOR (islower (i), ISLOWER (i))
7361 >        || toupper (i) != TOUPPER (i))
7362 >      exit(2);
7363 >  exit (0);
7364 > }
7365 > _ACEOF
7366 > rm -f conftest$ac_exeext
7367 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7368 >  (eval $ac_link) 2>&5
7369 >  ac_status=$?
7370 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7371 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7372 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7373 >  (eval $ac_try) 2>&5
7374 >  ac_status=$?
7375 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7376 >  (exit $ac_status); }; }; then
7377 >  :
7378 > else
7379 >  echo "$as_me: program exited with status $ac_status" >&5
7380 > echo "$as_me: failed program was:" >&5
7381 > sed 's/^/| /' conftest.$ac_ext >&5
7382 >
7383 > ( exit $ac_status )
7384 > ac_cv_header_stdc=no
7385 > fi
7386 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7387 > fi
7388 > fi
7389 > fi
7390 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7391 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7392 > if test $ac_cv_header_stdc = yes; then
7393 >
7394 > cat >>confdefs.h <<\_ACEOF
7395 > #define STDC_HEADERS 1
7396 > _ACEOF
7397 >
7398 > fi
7399 >
7400 >
7401 >
7402 >
7403 >
7404 >
7405 >
7406 >
7407 >
7408 >
7409 >
7410 >
7411 >
7412 >
7413 >
7414 >
7415 >
7416 >
7417 >
7418 >
7419 >
7420 >
7421 >
7422 >
7423 >
7424 >
7425 > for ac_header in conio.h dlfcn.h fstream.h iostream.h libintl.h limits.h machine/hal_sysinfo.h math.h stddef.h stdio.h stdlib.h string.h strings.h strstream.h sys/param.h sys/pstat.h sys/sysmp.h sys/sysctl.h sys/sysinfo.h sys/systemcfg.h sys/table.h sys/time.h time.h unistd.h zlib.h
7426 > do
7427 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7428 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7429 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7430 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7431 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7432 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7433 > fi
7434 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7435 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7436 > else
7437 >  # Is the header compilable?
7438 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7439 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7440 > cat >conftest.$ac_ext <<_ACEOF
7441 > /* confdefs.h.  */
7442 > _ACEOF
7443 > cat confdefs.h >>conftest.$ac_ext
7444 > cat >>conftest.$ac_ext <<_ACEOF
7445 > /* end confdefs.h.  */
7446 > $ac_includes_default
7447 > #include <$ac_header>
7448 > _ACEOF
7449 > rm -f conftest.$ac_objext
7450 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7451 >  (eval $ac_compile) 2>conftest.er1
7452 >  ac_status=$?
7453 >  grep -v '^ *+' conftest.er1 >conftest.err
7454 >  rm -f conftest.er1
7455 >  cat conftest.err >&5
7456 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7457 >  (exit $ac_status); } &&
7458 >         { ac_try='test -z "$ac_c_werror_flag"
7459 >                         || test ! -s conftest.err'
7460 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7461 >  (eval $ac_try) 2>&5
7462 >  ac_status=$?
7463 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7464 >  (exit $ac_status); }; } &&
7465 >         { ac_try='test -s conftest.$ac_objext'
7466 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7467 >  (eval $ac_try) 2>&5
7468 >  ac_status=$?
7469 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7470 >  (exit $ac_status); }; }; then
7471 >  ac_header_compiler=yes
7472 > else
7473 >  echo "$as_me: failed program was:" >&5
7474 > sed 's/^/| /' conftest.$ac_ext >&5
7475 >
7476 > ac_header_compiler=no
7477 > fi
7478 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7479 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7480 > echo "${ECHO_T}$ac_header_compiler" >&6
7481 >
7482 > # Is the header present?
7483 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7484 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7485 > cat >conftest.$ac_ext <<_ACEOF
7486 > /* confdefs.h.  */
7487 > _ACEOF
7488 > cat confdefs.h >>conftest.$ac_ext
7489 > cat >>conftest.$ac_ext <<_ACEOF
7490 > /* end confdefs.h.  */
7491 > #include <$ac_header>
7492 > _ACEOF
7493 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7494 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7495 >  ac_status=$?
7496 >  grep -v '^ *+' conftest.er1 >conftest.err
7497 >  rm -f conftest.er1
7498 >  cat conftest.err >&5
7499 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7500 >  (exit $ac_status); } >/dev/null; then
7501 >  if test -s conftest.err; then
7502 >    ac_cpp_err=$ac_c_preproc_warn_flag
7503 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7504 >  else
7505 >    ac_cpp_err=
7506 >  fi
7507 > else
7508 >  ac_cpp_err=yes
7509 > fi
7510 > if test -z "$ac_cpp_err"; then
7511 >  ac_header_preproc=yes
7512 > else
7513 >  echo "$as_me: failed program was:" >&5
7514 > sed 's/^/| /' conftest.$ac_ext >&5
7515 >
7516 >  ac_header_preproc=no
7517 > fi
7518 > rm -f conftest.err conftest.$ac_ext
7519 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7520 > echo "${ECHO_T}$ac_header_preproc" >&6
7521 >
7522 > # So?  What about this header?
7523 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7524 >  yes:no: )
7525 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7526 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7527 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7528 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7529 >    ac_header_preproc=yes
7530 >    ;;
7531 >  no:yes:* )
7532 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7533 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7534 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7535 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7536 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7537 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7538 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7539 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7540 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7541 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7542 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7543 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7544 >    (
7545 >      cat <<\_ASBOX
7546 > ## ------------------------------ ##
7547 > ## Report this to gezelter@nd.edu ##
7548 > ## ------------------------------ ##
7549 > _ASBOX
7550 >    ) |
7551 >      sed "s/^/$as_me: WARNING:     /" >&2
7552 >    ;;
7553 > esac
7554 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7555 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7556 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7557 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7558 > else
7559 >  eval "$as_ac_Header=\$ac_header_preproc"
7560 > fi
7561 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7562 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7563 >
7564 > fi
7565 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7566 >  cat >>confdefs.h <<_ACEOF
7567 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7568 > _ACEOF
7569 >
7570 > fi
7571 >
7572 > done
7573 >
7574 >
7575 > # Checks for typedefs, structures, and compiler characteristics.
7576 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7577 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7578 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7579 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7580 > else
7581 >  cat >conftest.$ac_ext <<_ACEOF
7582 > /* confdefs.h.  */
7583 > _ACEOF
7584 > cat confdefs.h >>conftest.$ac_ext
7585 > cat >>conftest.$ac_ext <<_ACEOF
7586 > /* end confdefs.h.  */
7587 >
7588 > #include <stdbool.h>
7589 > #ifndef bool
7590 > # error bool is not defined
7591 > #endif
7592 > #ifndef false
7593 > # error false is not defined
7594 > #endif
7595 > #if false
7596 > # error false is not 0
7597 > #endif
7598 > #ifndef true
7599 > # error true is not defined
7600 > #endif
7601 > #if true != 1
7602 > # error true is not 1
7603 > #endif
7604 > #ifndef __bool_true_false_are_defined
7605 > # error __bool_true_false_are_defined is not defined
7606 > #endif
7607 >
7608 >        struct s { _Bool s: 1; _Bool t; } s;
7609 >
7610 >        char a[true == 1 ? 1 : -1];
7611 >        char b[false == 0 ? 1 : -1];
7612 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7613 >        char d[(bool) -0.5 == true ? 1 : -1];
7614 >        bool e = &s;
7615 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7616 >        char g[true];
7617 >        char h[sizeof (_Bool)];
7618 >        char i[sizeof s.t];
7619 >
7620 > #ifdef FC_DUMMY_MAIN
7621 > #ifndef FC_DUMMY_MAIN_EQ_F77
7622 > #  ifdef __cplusplus
7623 >     extern "C"
7624 > #  endif
7625 >   int FC_DUMMY_MAIN() { return 1; }
7626 > #endif
7627 > #endif
7628 > int
7629 > main ()
7630 > {
7631 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7632 >  ;
7633 >  return 0;
7634 > }
7635 > _ACEOF
7636 > rm -f conftest.$ac_objext
7637 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7638 >  (eval $ac_compile) 2>conftest.er1
7639 >  ac_status=$?
7640 >  grep -v '^ *+' conftest.er1 >conftest.err
7641 >  rm -f conftest.er1
7642 >  cat conftest.err >&5
7643 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7644 >  (exit $ac_status); } &&
7645 >         { ac_try='test -z "$ac_c_werror_flag"
7646 >                         || test ! -s conftest.err'
7647 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7648 >  (eval $ac_try) 2>&5
7649 >  ac_status=$?
7650 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7651 >  (exit $ac_status); }; } &&
7652 >         { ac_try='test -s conftest.$ac_objext'
7653 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7654 >  (eval $ac_try) 2>&5
7655 >  ac_status=$?
7656 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7657 >  (exit $ac_status); }; }; then
7658 >  ac_cv_header_stdbool_h=yes
7659 > else
7660 >  echo "$as_me: failed program was:" >&5
7661 > sed 's/^/| /' conftest.$ac_ext >&5
7662 >
7663 > ac_cv_header_stdbool_h=no
7664 > fi
7665 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7666 > fi
7667 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7668 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7669 > echo "$as_me:$LINENO: checking for _Bool" >&5
7670 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7671 > if test "${ac_cv_type__Bool+set}" = set; then
7672 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7673 > else
7674 >  cat >conftest.$ac_ext <<_ACEOF
7675 > /* confdefs.h.  */
7676 > _ACEOF
7677 > cat confdefs.h >>conftest.$ac_ext
7678 > cat >>conftest.$ac_ext <<_ACEOF
7679 > /* end confdefs.h.  */
7680 > $ac_includes_default
7681 > #ifdef FC_DUMMY_MAIN
7682 > #ifndef FC_DUMMY_MAIN_EQ_F77
7683 > #  ifdef __cplusplus
7684 >     extern "C"
7685 > #  endif
7686 >   int FC_DUMMY_MAIN() { return 1; }
7687 > #endif
7688 > #endif
7689 > int
7690 > main ()
7691 > {
7692 > if ((_Bool *) 0)
7693 >  return 0;
7694 > if (sizeof (_Bool))
7695 >  return 0;
7696 >  ;
7697 >  return 0;
7698 > }
7699 > _ACEOF
7700 > rm -f conftest.$ac_objext
7701 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7702 >  (eval $ac_compile) 2>conftest.er1
7703 >  ac_status=$?
7704 >  grep -v '^ *+' conftest.er1 >conftest.err
7705 >  rm -f conftest.er1
7706 >  cat conftest.err >&5
7707 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7708 >  (exit $ac_status); } &&
7709 >         { ac_try='test -z "$ac_c_werror_flag"
7710 >                         || test ! -s conftest.err'
7711 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7712 >  (eval $ac_try) 2>&5
7713 >  ac_status=$?
7714 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7715 >  (exit $ac_status); }; } &&
7716 >         { ac_try='test -s conftest.$ac_objext'
7717 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7718 >  (eval $ac_try) 2>&5
7719 >  ac_status=$?
7720 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7721 >  (exit $ac_status); }; }; then
7722 >  ac_cv_type__Bool=yes
7723 > else
7724 >  echo "$as_me: failed program was:" >&5
7725 > sed 's/^/| /' conftest.$ac_ext >&5
7726 >
7727 > ac_cv_type__Bool=no
7728 > fi
7729 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7730 > fi
7731 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7732 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7733 > if test $ac_cv_type__Bool = yes; then
7734 >
7735 > cat >>confdefs.h <<_ACEOF
7736 > #define HAVE__BOOL 1
7737 > _ACEOF
7738 >
7739 >
7740 > fi
7741 >
7742 > if test $ac_cv_header_stdbool_h = yes; then
7743 >
7744 > cat >>confdefs.h <<\_ACEOF
7745 > #define HAVE_STDBOOL_H 1
7746 > _ACEOF
7747 >
7748 > fi
7749 >
7750 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7751 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7752 > if test "${ac_cv_c_const+set}" = set; then
7753 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7754 > else
7755 >  cat >conftest.$ac_ext <<_ACEOF
7756 > /* confdefs.h.  */
7757 > _ACEOF
7758 > cat confdefs.h >>conftest.$ac_ext
7759 > cat >>conftest.$ac_ext <<_ACEOF
7760 > /* end confdefs.h.  */
7761 >
7762 > #ifdef FC_DUMMY_MAIN
7763 > #ifndef FC_DUMMY_MAIN_EQ_F77
7764 > #  ifdef __cplusplus
7765 >     extern "C"
7766 > #  endif
7767 >   int FC_DUMMY_MAIN() { return 1; }
7768 > #endif
7769 > #endif
7770 > int
7771 > main ()
7772 > {
7773 > /* FIXME: Include the comments suggested by Paul. */
7774 > #ifndef __cplusplus
7775 >  /* Ultrix mips cc rejects this.  */
7776 >  typedef int charset[2];
7777 >  const charset x;
7778 >  /* SunOS 4.1.1 cc rejects this.  */
7779 >  char const *const *ccp;
7780 >  char **p;
7781 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7782 >  struct point {int x, y;};
7783 >  static struct point const zero = {0,0};
7784 >  /* AIX XL C 1.02.0.0 rejects this.
7785 >     It does not let you subtract one const X* pointer from another in
7786 >     an arm of an if-expression whose if-part is not a constant
7787 >     expression */
7788 >  const char *g = "string";
7789 >  ccp = &g + (g ? g-g : 0);
7790 >  /* HPUX 7.0 cc rejects these. */
7791 >  ++ccp;
7792 >  p = (char**) ccp;
7793 >  ccp = (char const *const *) p;
7794 >  { /* SCO 3.2v4 cc rejects this.  */
7795 >    char *t;
7796 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7797 >
7798 >    *t++ = 0;
7799 >  }
7800 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7801 >    int x[] = {25, 17};
7802 >    const int *foo = &x[0];
7803 >    ++foo;
7804 >  }
7805 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7806 >    typedef const int *iptr;
7807 >    iptr p = 0;
7808 >    ++p;
7809 >  }
7810 >  { /* AIX XL C 1.02.0.0 rejects this saying
7811 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7812 >    struct s { int j; const int *ap[3]; };
7813 >    struct s *b; b->j = 5;
7814 >  }
7815 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7816 >    const int foo = 10;
7817 >  }
7818 > #endif
7819 >
7820 >  ;
7821 >  return 0;
7822 > }
7823 > _ACEOF
7824 > rm -f conftest.$ac_objext
7825 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7826 >  (eval $ac_compile) 2>conftest.er1
7827 >  ac_status=$?
7828 >  grep -v '^ *+' conftest.er1 >conftest.err
7829 >  rm -f conftest.er1
7830 >  cat conftest.err >&5
7831 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7832 >  (exit $ac_status); } &&
7833 >         { ac_try='test -z "$ac_c_werror_flag"
7834 >                         || test ! -s conftest.err'
7835 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7836 >  (eval $ac_try) 2>&5
7837 >  ac_status=$?
7838 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7839 >  (exit $ac_status); }; } &&
7840 >         { ac_try='test -s conftest.$ac_objext'
7841 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7842 >  (eval $ac_try) 2>&5
7843 >  ac_status=$?
7844 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7845 >  (exit $ac_status); }; }; then
7846 >  ac_cv_c_const=yes
7847 > else
7848 >  echo "$as_me: failed program was:" >&5
7849 > sed 's/^/| /' conftest.$ac_ext >&5
7850 >
7851 > ac_cv_c_const=no
7852 > fi
7853 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7854 > fi
7855 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7856 > echo "${ECHO_T}$ac_cv_c_const" >&6
7857 > if test $ac_cv_c_const = no; then
7858 >
7859 > cat >>confdefs.h <<\_ACEOF
7860 > #define const
7861 > _ACEOF
7862 >
7863 > fi
7864 >
7865 > echo "$as_me:$LINENO: checking for inline" >&5
7866 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7867 > if test "${ac_cv_c_inline+set}" = set; then
7868 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7869 > else
7870 >  ac_cv_c_inline=no
7871 > for ac_kw in inline __inline__ __inline; do
7872 >  cat >conftest.$ac_ext <<_ACEOF
7873 > /* confdefs.h.  */
7874 > _ACEOF
7875 > cat confdefs.h >>conftest.$ac_ext
7876 > cat >>conftest.$ac_ext <<_ACEOF
7877 > /* end confdefs.h.  */
7878 > #ifndef __cplusplus
7879 > typedef int foo_t;
7880 > static $ac_kw foo_t static_foo () {return 0; }
7881 > $ac_kw foo_t foo () {return 0; }
7882 > #endif
7883 >
7884 > _ACEOF
7885 > rm -f conftest.$ac_objext
7886 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7887 >  (eval $ac_compile) 2>conftest.er1
7888 >  ac_status=$?
7889 >  grep -v '^ *+' conftest.er1 >conftest.err
7890 >  rm -f conftest.er1
7891 >  cat conftest.err >&5
7892 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7893 >  (exit $ac_status); } &&
7894 >         { ac_try='test -z "$ac_c_werror_flag"
7895 >                         || test ! -s conftest.err'
7896 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7897 >  (eval $ac_try) 2>&5
7898 >  ac_status=$?
7899 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7900 >  (exit $ac_status); }; } &&
7901 >         { ac_try='test -s conftest.$ac_objext'
7902 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7903 >  (eval $ac_try) 2>&5
7904 >  ac_status=$?
7905 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7906 >  (exit $ac_status); }; }; then
7907 >  ac_cv_c_inline=$ac_kw; break
7908 > else
7909 >  echo "$as_me: failed program was:" >&5
7910 > sed 's/^/| /' conftest.$ac_ext >&5
7911 >
7912 > fi
7913 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7914 > done
7915 >
7916 > fi
7917 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7918 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7919 >
7920 >
7921 > case $ac_cv_c_inline in
7922 >  inline | yes) ;;
7923 >  *)
7924 >    case $ac_cv_c_inline in
7925 >      no) ac_val=;;
7926 >      *) ac_val=$ac_cv_c_inline;;
7927 >    esac
7928 >    cat >>confdefs.h <<_ACEOF
7929 > #ifndef __cplusplus
7930 > #define inline $ac_val
7931 > #endif
7932 > _ACEOF
7933 >    ;;
7934 > esac
7935 >
7936 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7937 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7938 > if test "${ac_cv_c_restrict+set}" = set; then
7939 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7940 > else
7941 >  ac_cv_c_restrict=no
7942 >   # Try the official restrict keyword, then gcc's __restrict, and
7943 >   # the less common variants.
7944 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
7945 >     cat >conftest.$ac_ext <<_ACEOF
7946 > /* confdefs.h.  */
7947 > _ACEOF
7948 > cat confdefs.h >>conftest.$ac_ext
7949 > cat >>conftest.$ac_ext <<_ACEOF
7950 > /* end confdefs.h.  */
7951 > float * $ac_kw x;
7952 > _ACEOF
7953 > rm -f conftest.$ac_objext
7954 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7955 >  (eval $ac_compile) 2>conftest.er1
7956 >  ac_status=$?
7957 >  grep -v '^ *+' conftest.er1 >conftest.err
7958 >  rm -f conftest.er1
7959 >  cat conftest.err >&5
7960 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7961 >  (exit $ac_status); } &&
7962 >         { ac_try='test -z "$ac_c_werror_flag"
7963 >                         || test ! -s conftest.err'
7964 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7965 >  (eval $ac_try) 2>&5
7966 >  ac_status=$?
7967 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7968 >  (exit $ac_status); }; } &&
7969 >         { ac_try='test -s conftest.$ac_objext'
7970 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7971 >  (eval $ac_try) 2>&5
7972 >  ac_status=$?
7973 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7974 >  (exit $ac_status); }; }; then
7975 >  ac_cv_c_restrict=$ac_kw; break
7976 > else
7977 >  echo "$as_me: failed program was:" >&5
7978 > sed 's/^/| /' conftest.$ac_ext >&5
7979 >
7980 > fi
7981 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7982 >   done
7983 >
7984 > fi
7985 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7986 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
7987 > case $ac_cv_c_restrict in
7988 >   restrict) ;;
7989 >   no)
7990 > cat >>confdefs.h <<\_ACEOF
7991 > #define restrict
7992 > _ACEOF
7993 > ;;
7994 >   *)  cat >>confdefs.h <<_ACEOF
7995 > #define restrict $ac_cv_c_restrict
7996 > _ACEOF
7997 > ;;
7998 > esac
7999 >
8000 > echo "$as_me:$LINENO: checking for size_t" >&5
8001 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
8002 > if test "${ac_cv_type_size_t+set}" = set; then
8003 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8004 > else
8005 >  cat >conftest.$ac_ext <<_ACEOF
8006 > /* confdefs.h.  */
8007 > _ACEOF
8008 > cat confdefs.h >>conftest.$ac_ext
8009 > cat >>conftest.$ac_ext <<_ACEOF
8010 > /* end confdefs.h.  */
8011 > $ac_includes_default
8012 > #ifdef FC_DUMMY_MAIN
8013 > #ifndef FC_DUMMY_MAIN_EQ_F77
8014 > #  ifdef __cplusplus
8015 >     extern "C"
8016 > #  endif
8017 >   int FC_DUMMY_MAIN() { return 1; }
8018 > #endif
8019 > #endif
8020 > int
8021 > main ()
8022 > {
8023 > if ((size_t *) 0)
8024 >  return 0;
8025 > if (sizeof (size_t))
8026 >  return 0;
8027 >  ;
8028 >  return 0;
8029 > }
8030 > _ACEOF
8031 > rm -f conftest.$ac_objext
8032 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8033 >  (eval $ac_compile) 2>conftest.er1
8034 >  ac_status=$?
8035 >  grep -v '^ *+' conftest.er1 >conftest.err
8036 >  rm -f conftest.er1
8037 >  cat conftest.err >&5
8038 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8039 >  (exit $ac_status); } &&
8040 >         { ac_try='test -z "$ac_c_werror_flag"
8041 >                         || test ! -s conftest.err'
8042 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8043 >  (eval $ac_try) 2>&5
8044 >  ac_status=$?
8045 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8046 >  (exit $ac_status); }; } &&
8047 >         { ac_try='test -s conftest.$ac_objext'
8048 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8049 >  (eval $ac_try) 2>&5
8050 >  ac_status=$?
8051 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8052 >  (exit $ac_status); }; }; then
8053 >  ac_cv_type_size_t=yes
8054 > else
8055 >  echo "$as_me: failed program was:" >&5
8056 > sed 's/^/| /' conftest.$ac_ext >&5
8057 >
8058 > ac_cv_type_size_t=no
8059 > fi
8060 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8061 > fi
8062 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
8063 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
8064 > if test $ac_cv_type_size_t = yes; then
8065 >  :
8066 > else
8067 >
8068 > cat >>confdefs.h <<_ACEOF
8069 > #define size_t unsigned
8070 > _ACEOF
8071 >
8072 > fi
8073 >
8074 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
8075 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
8076 > if test "${ac_cv_header_time+set}" = set; then
8077 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8078 > else
8079 >  cat >conftest.$ac_ext <<_ACEOF
8080 > /* confdefs.h.  */
8081 > _ACEOF
8082 > cat confdefs.h >>conftest.$ac_ext
8083 > cat >>conftest.$ac_ext <<_ACEOF
8084 > /* end confdefs.h.  */
8085 > #include <sys/types.h>
8086 > #include <sys/time.h>
8087 > #include <time.h>
8088 >
8089 > #ifdef FC_DUMMY_MAIN
8090 > #ifndef FC_DUMMY_MAIN_EQ_F77
8091 > #  ifdef __cplusplus
8092 >     extern "C"
8093 > #  endif
8094 >   int FC_DUMMY_MAIN() { return 1; }
8095 > #endif
8096 > #endif
8097 > int
8098 > main ()
8099 > {
8100 > if ((struct tm *) 0)
8101 > return 0;
8102 >  ;
8103 >  return 0;
8104 > }
8105 > _ACEOF
8106 > rm -f conftest.$ac_objext
8107 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8108 >  (eval $ac_compile) 2>conftest.er1
8109 >  ac_status=$?
8110 >  grep -v '^ *+' conftest.er1 >conftest.err
8111 >  rm -f conftest.er1
8112 >  cat conftest.err >&5
8113 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8114 >  (exit $ac_status); } &&
8115 >         { ac_try='test -z "$ac_c_werror_flag"
8116 >                         || test ! -s conftest.err'
8117 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8118 >  (eval $ac_try) 2>&5
8119 >  ac_status=$?
8120 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8121 >  (exit $ac_status); }; } &&
8122 >         { ac_try='test -s conftest.$ac_objext'
8123 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8124 >  (eval $ac_try) 2>&5
8125 >  ac_status=$?
8126 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8127 >  (exit $ac_status); }; }; then
8128 >  ac_cv_header_time=yes
8129 > else
8130 >  echo "$as_me: failed program was:" >&5
8131 > sed 's/^/| /' conftest.$ac_ext >&5
8132 >
8133 > ac_cv_header_time=no
8134 > fi
8135 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8136 > fi
8137 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
8138 > echo "${ECHO_T}$ac_cv_header_time" >&6
8139 > if test $ac_cv_header_time = yes; then
8140 >
8141 > cat >>confdefs.h <<\_ACEOF
8142 > #define TIME_WITH_SYS_TIME 1
8143 > _ACEOF
8144 >
8145 > fi
8146 >
8147 > echo "$as_me:$LINENO: checking for clock_t" >&5
8148 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
8149 > if test "${ac_cv_type_clock_t+set}" = set; then
8150 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8151 > else
8152 >  cat >conftest.$ac_ext <<_ACEOF
8153 > /* confdefs.h.  */
8154 > _ACEOF
8155 > cat confdefs.h >>conftest.$ac_ext
8156 > cat >>conftest.$ac_ext <<_ACEOF
8157 > /* end confdefs.h.  */
8158 > $ac_includes_default
8159 > #ifdef FC_DUMMY_MAIN
8160 > #ifndef FC_DUMMY_MAIN_EQ_F77
8161 > #  ifdef __cplusplus
8162 >     extern "C"
8163 > #  endif
8164 >   int FC_DUMMY_MAIN() { return 1; }
8165 > #endif
8166 > #endif
8167 > int
8168 > main ()
8169 > {
8170 > if ((clock_t *) 0)
8171 >  return 0;
8172 > if (sizeof (clock_t))
8173 >  return 0;
8174 >  ;
8175 >  return 0;
8176 > }
8177 > _ACEOF
8178 > rm -f conftest.$ac_objext
8179 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8180 >  (eval $ac_compile) 2>conftest.er1
8181 >  ac_status=$?
8182 >  grep -v '^ *+' conftest.er1 >conftest.err
8183 >  rm -f conftest.er1
8184 >  cat conftest.err >&5
8185 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8186 >  (exit $ac_status); } &&
8187 >         { ac_try='test -z "$ac_c_werror_flag"
8188 >                         || test ! -s conftest.err'
8189 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8190 >  (eval $ac_try) 2>&5
8191 >  ac_status=$?
8192 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8193 >  (exit $ac_status); }; } &&
8194 >         { ac_try='test -s conftest.$ac_objext'
8195 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8196 >  (eval $ac_try) 2>&5
8197 >  ac_status=$?
8198 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8199 >  (exit $ac_status); }; }; then
8200 >  ac_cv_type_clock_t=yes
8201 > else
8202 >  echo "$as_me: failed program was:" >&5
8203 > sed 's/^/| /' conftest.$ac_ext >&5
8204 >
8205 > ac_cv_type_clock_t=no
8206 > fi
8207 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8208 > fi
8209 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
8210 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
8211 > if test $ac_cv_type_clock_t = yes; then
8212 >
8213 > cat >>confdefs.h <<_ACEOF
8214 > #define HAVE_CLOCK_T 1
8215 > _ACEOF
8216 >
8217 >
8218 > fi
8219 >
8220 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
8221 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
8222 > if test "${ac_cv_c_const+set}" = set; then
8223 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8224 > else
8225 >  cat >conftest.$ac_ext <<_ACEOF
8226 > /* confdefs.h.  */
8227 > _ACEOF
8228 > cat confdefs.h >>conftest.$ac_ext
8229 > cat >>conftest.$ac_ext <<_ACEOF
8230 > /* end confdefs.h.  */
8231 >
8232 > #ifdef FC_DUMMY_MAIN
8233 > #ifndef FC_DUMMY_MAIN_EQ_F77
8234 > #  ifdef __cplusplus
8235 >     extern "C"
8236 > #  endif
8237 >   int FC_DUMMY_MAIN() { return 1; }
8238 > #endif
8239 > #endif
8240 > int
8241 > main ()
8242 > {
8243 > /* FIXME: Include the comments suggested by Paul. */
8244 > #ifndef __cplusplus
8245 >  /* Ultrix mips cc rejects this.  */
8246 >  typedef int charset[2];
8247 >  const charset x;
8248 >  /* SunOS 4.1.1 cc rejects this.  */
8249 >  char const *const *ccp;
8250 >  char **p;
8251 >  /* NEC SVR4.0.2 mips cc rejects this.  */
8252 >  struct point {int x, y;};
8253 >  static struct point const zero = {0,0};
8254 >  /* AIX XL C 1.02.0.0 rejects this.
8255 >     It does not let you subtract one const X* pointer from another in
8256 >     an arm of an if-expression whose if-part is not a constant
8257 >     expression */
8258 >  const char *g = "string";
8259 >  ccp = &g + (g ? g-g : 0);
8260 >  /* HPUX 7.0 cc rejects these. */
8261 >  ++ccp;
8262 >  p = (char**) ccp;
8263 >  ccp = (char const *const *) p;
8264 >  { /* SCO 3.2v4 cc rejects this.  */
8265 >    char *t;
8266 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
8267 >
8268 >    *t++ = 0;
8269 >  }
8270 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
8271 >    int x[] = {25, 17};
8272 >    const int *foo = &x[0];
8273 >    ++foo;
8274 >  }
8275 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
8276 >    typedef const int *iptr;
8277 >    iptr p = 0;
8278 >    ++p;
8279 >  }
8280 >  { /* AIX XL C 1.02.0.0 rejects this saying
8281 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
8282 >    struct s { int j; const int *ap[3]; };
8283 >    struct s *b; b->j = 5;
8284 >  }
8285 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
8286 >    const int foo = 10;
8287 >  }
8288 > #endif
8289 >
8290 >  ;
8291 >  return 0;
8292 > }
8293 > _ACEOF
8294 > rm -f conftest.$ac_objext
8295 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8296 >  (eval $ac_compile) 2>conftest.er1
8297 >  ac_status=$?
8298 >  grep -v '^ *+' conftest.er1 >conftest.err
8299 >  rm -f conftest.er1
8300 >  cat conftest.err >&5
8301 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8302 >  (exit $ac_status); } &&
8303 >         { ac_try='test -z "$ac_c_werror_flag"
8304 >                         || test ! -s conftest.err'
8305 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8306 >  (eval $ac_try) 2>&5
8307 >  ac_status=$?
8308 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8309 >  (exit $ac_status); }; } &&
8310 >         { ac_try='test -s conftest.$ac_objext'
8311 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8312 >  (eval $ac_try) 2>&5
8313 >  ac_status=$?
8314 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8315 >  (exit $ac_status); }; }; then
8316 >  ac_cv_c_const=yes
8317 > else
8318 >  echo "$as_me: failed program was:" >&5
8319 > sed 's/^/| /' conftest.$ac_ext >&5
8320 >
8321 > ac_cv_c_const=no
8322 > fi
8323 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8324 > fi
8325 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8326 > echo "${ECHO_T}$ac_cv_c_const" >&6
8327 > if test $ac_cv_c_const = no; then
8328 >
8329 > cat >>confdefs.h <<\_ACEOF
8330 > #define const
8331 > _ACEOF
8332 >
8333 > fi
8334 >
8335 > echo "$as_me:$LINENO: checking for inline" >&5
8336 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8337 > if test "${ac_cv_c_inline+set}" = set; then
8338 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8339 > else
8340 >  ac_cv_c_inline=no
8341 > for ac_kw in inline __inline__ __inline; do
8342 >  cat >conftest.$ac_ext <<_ACEOF
8343 > /* confdefs.h.  */
8344 > _ACEOF
8345 > cat confdefs.h >>conftest.$ac_ext
8346 > cat >>conftest.$ac_ext <<_ACEOF
8347 > /* end confdefs.h.  */
8348 > #ifndef __cplusplus
8349 > typedef int foo_t;
8350 > static $ac_kw foo_t static_foo () {return 0; }
8351 > $ac_kw foo_t foo () {return 0; }
8352 > #endif
8353 >
8354 > _ACEOF
8355 > rm -f conftest.$ac_objext
8356 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8357 >  (eval $ac_compile) 2>conftest.er1
8358 >  ac_status=$?
8359 >  grep -v '^ *+' conftest.er1 >conftest.err
8360 >  rm -f conftest.er1
8361 >  cat conftest.err >&5
8362 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8363 >  (exit $ac_status); } &&
8364 >         { ac_try='test -z "$ac_c_werror_flag"
8365 >                         || test ! -s conftest.err'
8366 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8367 >  (eval $ac_try) 2>&5
8368 >  ac_status=$?
8369 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8370 >  (exit $ac_status); }; } &&
8371 >         { ac_try='test -s conftest.$ac_objext'
8372 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8373 >  (eval $ac_try) 2>&5
8374 >  ac_status=$?
8375 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8376 >  (exit $ac_status); }; }; then
8377 >  ac_cv_c_inline=$ac_kw; break
8378 > else
8379 >  echo "$as_me: failed program was:" >&5
8380 > sed 's/^/| /' conftest.$ac_ext >&5
8381 >
8382 > fi
8383 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8384 > done
8385 >
8386 > fi
8387 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8388 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8389 >
8390 >
8391 > case $ac_cv_c_inline in
8392 >  inline | yes) ;;
8393 >  *)
8394 >    case $ac_cv_c_inline in
8395 >      no) ac_val=;;
8396 >      *) ac_val=$ac_cv_c_inline;;
8397 >    esac
8398 >    cat >>confdefs.h <<_ACEOF
8399 > #ifndef __cplusplus
8400 > #define inline $ac_val
8401 > #endif
8402 > _ACEOF
8403 >    ;;
8404 > esac
8405 >
8406 >
8407 > # Checks for library functions.
8408 >
8409 > for ac_header in stdlib.h
8410 > do
8411 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8412 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8413 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8414 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8415 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8416 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8417 > fi
8418 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8419 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8420 > else
8421 >  # Is the header compilable?
8422 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8423 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8424 > cat >conftest.$ac_ext <<_ACEOF
8425 > /* confdefs.h.  */
8426 > _ACEOF
8427 > cat confdefs.h >>conftest.$ac_ext
8428 > cat >>conftest.$ac_ext <<_ACEOF
8429 > /* end confdefs.h.  */
8430 > $ac_includes_default
8431 > #include <$ac_header>
8432 > _ACEOF
8433 > rm -f conftest.$ac_objext
8434 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8435 >  (eval $ac_compile) 2>conftest.er1
8436 >  ac_status=$?
8437 >  grep -v '^ *+' conftest.er1 >conftest.err
8438 >  rm -f conftest.er1
8439 >  cat conftest.err >&5
8440 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8441 >  (exit $ac_status); } &&
8442 >         { ac_try='test -z "$ac_c_werror_flag"
8443 >                         || test ! -s conftest.err'
8444 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8445 >  (eval $ac_try) 2>&5
8446 >  ac_status=$?
8447 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8448 >  (exit $ac_status); }; } &&
8449 >         { ac_try='test -s conftest.$ac_objext'
8450 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8451 >  (eval $ac_try) 2>&5
8452 >  ac_status=$?
8453 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8454 >  (exit $ac_status); }; }; then
8455 >  ac_header_compiler=yes
8456 > else
8457 >  echo "$as_me: failed program was:" >&5
8458 > sed 's/^/| /' conftest.$ac_ext >&5
8459 >
8460 > ac_header_compiler=no
8461 > fi
8462 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8463 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8464 > echo "${ECHO_T}$ac_header_compiler" >&6
8465 >
8466 > # Is the header present?
8467 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8468 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8469 > cat >conftest.$ac_ext <<_ACEOF
8470 > /* confdefs.h.  */
8471 > _ACEOF
8472 > cat confdefs.h >>conftest.$ac_ext
8473 > cat >>conftest.$ac_ext <<_ACEOF
8474 > /* end confdefs.h.  */
8475 > #include <$ac_header>
8476 > _ACEOF
8477 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8478 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8479 >  ac_status=$?
8480 >  grep -v '^ *+' conftest.er1 >conftest.err
8481 >  rm -f conftest.er1
8482 >  cat conftest.err >&5
8483 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8484 >  (exit $ac_status); } >/dev/null; then
8485 >  if test -s conftest.err; then
8486 >    ac_cpp_err=$ac_c_preproc_warn_flag
8487 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8488 >  else
8489 >    ac_cpp_err=
8490 >  fi
8491 > else
8492 >  ac_cpp_err=yes
8493 > fi
8494 > if test -z "$ac_cpp_err"; then
8495 >  ac_header_preproc=yes
8496 > else
8497 >  echo "$as_me: failed program was:" >&5
8498 > sed 's/^/| /' conftest.$ac_ext >&5
8499 >
8500 >  ac_header_preproc=no
8501 > fi
8502 > rm -f conftest.err conftest.$ac_ext
8503 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8504 > echo "${ECHO_T}$ac_header_preproc" >&6
8505 >
8506 > # So?  What about this header?
8507 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8508 >  yes:no: )
8509 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8510 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8511 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8512 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8513 >    ac_header_preproc=yes
8514 >    ;;
8515 >  no:yes:* )
8516 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8517 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8518 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8519 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8520 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8521 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8522 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8523 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8524 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8525 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8526 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8527 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8528 >    (
8529 >      cat <<\_ASBOX
8530 > ## ------------------------------ ##
8531 > ## Report this to gezelter@nd.edu ##
8532 > ## ------------------------------ ##
8533 > _ASBOX
8534 >    ) |
8535 >      sed "s/^/$as_me: WARNING:     /" >&2
8536 >    ;;
8537 > esac
8538 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8539 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8540 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8541 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8542 > else
8543 >  eval "$as_ac_Header=\$ac_header_preproc"
8544 > fi
8545 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8546 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8547 >
8548 > fi
8549 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8550 >  cat >>confdefs.h <<_ACEOF
8551 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8552 > _ACEOF
8553 >
8554 > fi
8555 >
8556 > done
8557 >
8558 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8559 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8560 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8561 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8562 > else
8563 >  if test "$cross_compiling" = yes; then
8564 >  ac_cv_func_malloc_0_nonnull=no
8565 > else
8566 >  cat >conftest.$ac_ext <<_ACEOF
8567 > /* confdefs.h.  */
8568 > _ACEOF
8569 > cat confdefs.h >>conftest.$ac_ext
8570 > cat >>conftest.$ac_ext <<_ACEOF
8571 > /* end confdefs.h.  */
8572 > #if STDC_HEADERS || HAVE_STDLIB_H
8573 > # include <stdlib.h>
8574 > #else
8575 > char *malloc ();
8576 > #endif
8577 >
8578 > #ifdef FC_DUMMY_MAIN
8579 > #ifndef FC_DUMMY_MAIN_EQ_F77
8580 > #  ifdef __cplusplus
8581 >     extern "C"
8582 > #  endif
8583 >   int FC_DUMMY_MAIN() { return 1; }
8584 > #endif
8585 > #endif
8586 > int
8587 > main ()
8588 > {
8589 > exit (malloc (0) ? 0 : 1);
8590 >  ;
8591 >  return 0;
8592 > }
8593 > _ACEOF
8594 > rm -f conftest$ac_exeext
8595 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8596 >  (eval $ac_link) 2>&5
8597 >  ac_status=$?
8598 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8599 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8600 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8601 >  (eval $ac_try) 2>&5
8602 >  ac_status=$?
8603 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8604 >  (exit $ac_status); }; }; then
8605 >  ac_cv_func_malloc_0_nonnull=yes
8606 > else
8607 >  echo "$as_me: program exited with status $ac_status" >&5
8608 > echo "$as_me: failed program was:" >&5
8609 > sed 's/^/| /' conftest.$ac_ext >&5
8610 >
8611 > ( exit $ac_status )
8612 > ac_cv_func_malloc_0_nonnull=no
8613 > fi
8614 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8615 > fi
8616 > fi
8617 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8618 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8619 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8620 >
8621 > cat >>confdefs.h <<\_ACEOF
8622 > #define HAVE_MALLOC 1
8623 > _ACEOF
8624 >
8625 > else
8626 >  cat >>confdefs.h <<\_ACEOF
8627 > #define HAVE_MALLOC 0
8628 > _ACEOF
8629 >
8630 >   case $LIBOBJS in
8631 >    "malloc.$ac_objext"   | \
8632 >  *" malloc.$ac_objext"   | \
8633 >    "malloc.$ac_objext "* | \
8634 >  *" malloc.$ac_objext "* ) ;;
8635 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8636 > esac
8637 >
8638 >
8639 > cat >>confdefs.h <<\_ACEOF
8640 > #define malloc rpl_malloc
8641 > _ACEOF
8642 >
8643 > fi
8644 >
8645 >
8646 >
8647 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8648 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8649 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8650 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8651 > else
8652 >  if test "$cross_compiling" = yes; then
8653 >  ac_cv_func_memcmp_working=no
8654 > else
8655 >  cat >conftest.$ac_ext <<_ACEOF
8656 > /* confdefs.h.  */
8657 > _ACEOF
8658 > cat confdefs.h >>conftest.$ac_ext
8659 > cat >>conftest.$ac_ext <<_ACEOF
8660 > /* end confdefs.h.  */
8661 > $ac_includes_default
8662 > #ifdef FC_DUMMY_MAIN
8663 > #ifndef FC_DUMMY_MAIN_EQ_F77
8664 > #  ifdef __cplusplus
8665 >     extern "C"
8666 > #  endif
8667 >   int FC_DUMMY_MAIN() { return 1; }
8668 > #endif
8669 > #endif
8670 > int
8671 > main ()
8672 > {
8673 >
8674 >  /* Some versions of memcmp are not 8-bit clean.  */
8675 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8676 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8677 >    exit (1);
8678 >
8679 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8680 >     or more and with at least one buffer not starting on a 4-byte boundary.
8681 >     William Lewis provided this test program.   */
8682 >  {
8683 >    char foo[21];
8684 >    char bar[21];
8685 >    int i;
8686 >    for (i = 0; i < 4; i++)
8687 >      {
8688 >        char *a = foo + i;
8689 >        char *b = bar + i;
8690 >        strcpy (a, "--------01111111");
8691 >        strcpy (b, "--------10000000");
8692 >        if (memcmp (a, b, 16) >= 0)
8693 >          exit (1);
8694 >      }
8695 >    exit (0);
8696 >  }
8697 >
8698 >  ;
8699 >  return 0;
8700 > }
8701 > _ACEOF
8702 > rm -f conftest$ac_exeext
8703 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8704 >  (eval $ac_link) 2>&5
8705 >  ac_status=$?
8706 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8707 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8708 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8709 >  (eval $ac_try) 2>&5
8710 >  ac_status=$?
8711 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8712 >  (exit $ac_status); }; }; then
8713 >  ac_cv_func_memcmp_working=yes
8714 > else
8715 >  echo "$as_me: program exited with status $ac_status" >&5
8716 > echo "$as_me: failed program was:" >&5
8717 > sed 's/^/| /' conftest.$ac_ext >&5
8718 >
8719 > ( exit $ac_status )
8720 > ac_cv_func_memcmp_working=no
8721 > fi
8722 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8723 > fi
8724 > fi
8725 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8726 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8727 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8728 >    "memcmp.$ac_objext"   | \
8729 >  *" memcmp.$ac_objext"   | \
8730 >    "memcmp.$ac_objext "* | \
8731 >  *" memcmp.$ac_objext "* ) ;;
8732 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8733 > esac
8734 >
8735 >
8736 >
8737 > for ac_header in stdlib.h
8738 > do
8739 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8740 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8741 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8742 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8743 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8744 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8745 > fi
8746 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8747 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8748 > else
8749 >  # Is the header compilable?
8750 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8751 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8752 > cat >conftest.$ac_ext <<_ACEOF
8753 > /* confdefs.h.  */
8754 > _ACEOF
8755 > cat confdefs.h >>conftest.$ac_ext
8756 > cat >>conftest.$ac_ext <<_ACEOF
8757 > /* end confdefs.h.  */
8758 > $ac_includes_default
8759 > #include <$ac_header>
8760 > _ACEOF
8761 > rm -f conftest.$ac_objext
8762 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8763 >  (eval $ac_compile) 2>conftest.er1
8764 >  ac_status=$?
8765 >  grep -v '^ *+' conftest.er1 >conftest.err
8766 >  rm -f conftest.er1
8767 >  cat conftest.err >&5
8768 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8769 >  (exit $ac_status); } &&
8770 >         { ac_try='test -z "$ac_c_werror_flag"
8771 >                         || test ! -s conftest.err'
8772 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8773 >  (eval $ac_try) 2>&5
8774 >  ac_status=$?
8775 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8776 >  (exit $ac_status); }; } &&
8777 >         { ac_try='test -s conftest.$ac_objext'
8778 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8779 >  (eval $ac_try) 2>&5
8780 >  ac_status=$?
8781 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8782 >  (exit $ac_status); }; }; then
8783 >  ac_header_compiler=yes
8784 > else
8785 >  echo "$as_me: failed program was:" >&5
8786 > sed 's/^/| /' conftest.$ac_ext >&5
8787 >
8788 > ac_header_compiler=no
8789 > fi
8790 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8791 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8792 > echo "${ECHO_T}$ac_header_compiler" >&6
8793 >
8794 > # Is the header present?
8795 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8796 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8797 > cat >conftest.$ac_ext <<_ACEOF
8798 > /* confdefs.h.  */
8799 > _ACEOF
8800 > cat confdefs.h >>conftest.$ac_ext
8801 > cat >>conftest.$ac_ext <<_ACEOF
8802 > /* end confdefs.h.  */
8803 > #include <$ac_header>
8804 > _ACEOF
8805 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8806 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8807 >  ac_status=$?
8808 >  grep -v '^ *+' conftest.er1 >conftest.err
8809 >  rm -f conftest.er1
8810 >  cat conftest.err >&5
8811 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8812 >  (exit $ac_status); } >/dev/null; then
8813 >  if test -s conftest.err; then
8814 >    ac_cpp_err=$ac_c_preproc_warn_flag
8815 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8816 >  else
8817 >    ac_cpp_err=
8818 >  fi
8819 > else
8820 >  ac_cpp_err=yes
8821 > fi
8822 > if test -z "$ac_cpp_err"; then
8823 >  ac_header_preproc=yes
8824 > else
8825 >  echo "$as_me: failed program was:" >&5
8826 > sed 's/^/| /' conftest.$ac_ext >&5
8827 >
8828 >  ac_header_preproc=no
8829 > fi
8830 > rm -f conftest.err conftest.$ac_ext
8831 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8832 > echo "${ECHO_T}$ac_header_preproc" >&6
8833 >
8834 > # So?  What about this header?
8835 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8836 >  yes:no: )
8837 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8838 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8839 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8840 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8841 >    ac_header_preproc=yes
8842 >    ;;
8843 >  no:yes:* )
8844 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8845 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8846 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8847 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8848 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8849 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8850 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8851 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8852 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8853 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8854 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8855 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8856 >    (
8857 >      cat <<\_ASBOX
8858 > ## ------------------------------ ##
8859 > ## Report this to gezelter@nd.edu ##
8860 > ## ------------------------------ ##
8861 > _ASBOX
8862 >    ) |
8863 >      sed "s/^/$as_me: WARNING:     /" >&2
8864 >    ;;
8865 > esac
8866 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8867 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8868 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8869 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8870 > else
8871 >  eval "$as_ac_Header=\$ac_header_preproc"
8872 > fi
8873 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8874 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8875 >
8876 > fi
8877 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8878 >  cat >>confdefs.h <<_ACEOF
8879 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8880 > _ACEOF
8881 >
8882 > fi
8883 >
8884 > done
8885 >
8886 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8887 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8888 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8889 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8890 > else
8891 >  if test "$cross_compiling" = yes; then
8892 >  ac_cv_func_realloc_0_nonnull=no
8893 > else
8894 >  cat >conftest.$ac_ext <<_ACEOF
8895 > /* confdefs.h.  */
8896 > _ACEOF
8897 > cat confdefs.h >>conftest.$ac_ext
8898 > cat >>conftest.$ac_ext <<_ACEOF
8899 > /* end confdefs.h.  */
8900 > #if STDC_HEADERS || HAVE_STDLIB_H
8901 > # include <stdlib.h>
8902 > #else
8903 > char *realloc ();
8904 > #endif
8905 >
8906 > #ifdef FC_DUMMY_MAIN
8907 > #ifndef FC_DUMMY_MAIN_EQ_F77
8908 > #  ifdef __cplusplus
8909 >     extern "C"
8910 > #  endif
8911 >   int FC_DUMMY_MAIN() { return 1; }
8912 > #endif
8913 > #endif
8914 > int
8915 > main ()
8916 > {
8917 > exit (realloc (0, 0) ? 0 : 1);
8918 >  ;
8919 >  return 0;
8920 > }
8921 > _ACEOF
8922 > rm -f conftest$ac_exeext
8923 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8924 >  (eval $ac_link) 2>&5
8925 >  ac_status=$?
8926 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8927 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8928 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8929 >  (eval $ac_try) 2>&5
8930 >  ac_status=$?
8931 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8932 >  (exit $ac_status); }; }; then
8933 >  ac_cv_func_realloc_0_nonnull=yes
8934 > else
8935 >  echo "$as_me: program exited with status $ac_status" >&5
8936 > echo "$as_me: failed program was:" >&5
8937 > sed 's/^/| /' conftest.$ac_ext >&5
8938 >
8939 > ( exit $ac_status )
8940 > ac_cv_func_realloc_0_nonnull=no
8941 > fi
8942 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8943 > fi
8944 > fi
8945 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8946 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8947 > if test $ac_cv_func_realloc_0_nonnull = yes; then
8948 >
8949 > cat >>confdefs.h <<\_ACEOF
8950 > #define HAVE_REALLOC 1
8951 > _ACEOF
8952 >
8953 > else
8954 >  cat >>confdefs.h <<\_ACEOF
8955 > #define HAVE_REALLOC 0
8956 > _ACEOF
8957 >
8958 >   case $LIBOBJS in
8959 >    "realloc.$ac_objext"   | \
8960 >  *" realloc.$ac_objext"   | \
8961 >    "realloc.$ac_objext "* | \
8962 >  *" realloc.$ac_objext "* ) ;;
8963 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8964 > esac
8965 >
8966 >
8967 > cat >>confdefs.h <<\_ACEOF
8968 > #define realloc rpl_realloc
8969 > _ACEOF
8970 >
8971 > fi
8972 >
8973 >
8974 >
8975 >
8976 >
8977 > for ac_header in sys/select.h sys/socket.h
8978 > do
8979 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8980 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8981 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8982 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8983 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8984 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8985 > fi
8986 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8987 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8988 > else
8989 >  # Is the header compilable?
8990 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8991 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8992 > cat >conftest.$ac_ext <<_ACEOF
8993 > /* confdefs.h.  */
8994 > _ACEOF
8995 > cat confdefs.h >>conftest.$ac_ext
8996 > cat >>conftest.$ac_ext <<_ACEOF
8997 > /* end confdefs.h.  */
8998 > $ac_includes_default
8999 > #include <$ac_header>
9000 > _ACEOF
9001 > rm -f conftest.$ac_objext
9002 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9003 >  (eval $ac_compile) 2>conftest.er1
9004 >  ac_status=$?
9005 >  grep -v '^ *+' conftest.er1 >conftest.err
9006 >  rm -f conftest.er1
9007 >  cat conftest.err >&5
9008 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9009 >  (exit $ac_status); } &&
9010 >         { ac_try='test -z "$ac_c_werror_flag"
9011 >                         || test ! -s conftest.err'
9012 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9013 >  (eval $ac_try) 2>&5
9014 >  ac_status=$?
9015 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9016 >  (exit $ac_status); }; } &&
9017 >         { ac_try='test -s conftest.$ac_objext'
9018 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9019 >  (eval $ac_try) 2>&5
9020 >  ac_status=$?
9021 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9022 >  (exit $ac_status); }; }; then
9023 >  ac_header_compiler=yes
9024 > else
9025 >  echo "$as_me: failed program was:" >&5
9026 > sed 's/^/| /' conftest.$ac_ext >&5
9027 >
9028 > ac_header_compiler=no
9029 > fi
9030 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9031 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9032 > echo "${ECHO_T}$ac_header_compiler" >&6
9033 >
9034 > # Is the header present?
9035 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9036 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9037 > cat >conftest.$ac_ext <<_ACEOF
9038 > /* confdefs.h.  */
9039 > _ACEOF
9040 > cat confdefs.h >>conftest.$ac_ext
9041 > cat >>conftest.$ac_ext <<_ACEOF
9042 > /* end confdefs.h.  */
9043 > #include <$ac_header>
9044 > _ACEOF
9045 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9046 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9047 >  ac_status=$?
9048 >  grep -v '^ *+' conftest.er1 >conftest.err
9049 >  rm -f conftest.er1
9050 >  cat conftest.err >&5
9051 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9052 >  (exit $ac_status); } >/dev/null; then
9053 >  if test -s conftest.err; then
9054 >    ac_cpp_err=$ac_c_preproc_warn_flag
9055 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9056 >  else
9057 >    ac_cpp_err=
9058 >  fi
9059 > else
9060 >  ac_cpp_err=yes
9061 > fi
9062 > if test -z "$ac_cpp_err"; then
9063 >  ac_header_preproc=yes
9064 > else
9065 >  echo "$as_me: failed program was:" >&5
9066 > sed 's/^/| /' conftest.$ac_ext >&5
9067 >
9068 >  ac_header_preproc=no
9069 > fi
9070 > rm -f conftest.err conftest.$ac_ext
9071 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9072 > echo "${ECHO_T}$ac_header_preproc" >&6
9073 >
9074 > # So?  What about this header?
9075 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9076 >  yes:no: )
9077 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9078 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9079 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9080 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9081 >    ac_header_preproc=yes
9082 >    ;;
9083 >  no:yes:* )
9084 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9085 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9086 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9087 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9088 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9089 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9090 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9091 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9092 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9093 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9094 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9095 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9096 >    (
9097 >      cat <<\_ASBOX
9098 > ## ------------------------------ ##
9099 > ## Report this to gezelter@nd.edu ##
9100 > ## ------------------------------ ##
9101 > _ASBOX
9102 >    ) |
9103 >      sed "s/^/$as_me: WARNING:     /" >&2
9104 >    ;;
9105 > esac
9106 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9107 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9108 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9109 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9110 > else
9111 >  eval "$as_ac_Header=\$ac_header_preproc"
9112 > fi
9113 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9114 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9115 >
9116 > fi
9117 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9118 >  cat >>confdefs.h <<_ACEOF
9119 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9120 > _ACEOF
9121 >
9122 > fi
9123 >
9124 > done
9125 >
9126 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
9127 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
9128 > if test "${ac_cv_func_select_args+set}" = set; then
9129 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9130 > else
9131 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
9132 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
9133 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
9134 >   cat >conftest.$ac_ext <<_ACEOF
9135 > /* confdefs.h.  */
9136 > _ACEOF
9137 > cat confdefs.h >>conftest.$ac_ext
9138 > cat >>conftest.$ac_ext <<_ACEOF
9139 > /* end confdefs.h.  */
9140 > $ac_includes_default
9141 > #if HAVE_SYS_SELECT_H
9142 > # include <sys/select.h>
9143 > #endif
9144 > #if HAVE_SYS_SOCKET_H
9145 > # include <sys/socket.h>
9146 > #endif
9147 >
9148 > #ifdef FC_DUMMY_MAIN
9149 > #ifndef FC_DUMMY_MAIN_EQ_F77
9150 > #  ifdef __cplusplus
9151 >     extern "C"
9152 > #  endif
9153 >   int FC_DUMMY_MAIN() { return 1; }
9154 > #endif
9155 > #endif
9156 > int
9157 > main ()
9158 > {
9159 > extern int select ($ac_arg1,
9160 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
9161 >                                            $ac_arg5);
9162 >  ;
9163 >  return 0;
9164 > }
9165 > _ACEOF
9166 > rm -f conftest.$ac_objext
9167 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9168 >  (eval $ac_compile) 2>conftest.er1
9169 >  ac_status=$?
9170 >  grep -v '^ *+' conftest.er1 >conftest.err
9171 >  rm -f conftest.er1
9172 >  cat conftest.err >&5
9173 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9174 >  (exit $ac_status); } &&
9175 >         { ac_try='test -z "$ac_c_werror_flag"
9176 >                         || test ! -s conftest.err'
9177 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9178 >  (eval $ac_try) 2>&5
9179 >  ac_status=$?
9180 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9181 >  (exit $ac_status); }; } &&
9182 >         { ac_try='test -s conftest.$ac_objext'
9183 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9184 >  (eval $ac_try) 2>&5
9185 >  ac_status=$?
9186 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9187 >  (exit $ac_status); }; }; then
9188 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
9189 > else
9190 >  echo "$as_me: failed program was:" >&5
9191 > sed 's/^/| /' conftest.$ac_ext >&5
9192 >
9193 > fi
9194 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9195 >  done
9196 > done
9197 > done
9198 > # Provide a safe default value.
9199 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
9200 >
9201 > fi
9202 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
9203 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
9204 > ac_save_IFS=$IFS; IFS=','
9205 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
9206 > IFS=$ac_save_IFS
9207 > shift
9208 >
9209 > cat >>confdefs.h <<_ACEOF
9210 > #define SELECT_TYPE_ARG1 $1
9211 > _ACEOF
9212 >
9213 >
9214 > cat >>confdefs.h <<_ACEOF
9215 > #define SELECT_TYPE_ARG234 ($2)
9216 > _ACEOF
9217 >
9218 >
9219 > cat >>confdefs.h <<_ACEOF
9220 > #define SELECT_TYPE_ARG5 ($3)
9221 > _ACEOF
9222 >
9223 > rm -f conftest*
9224 >
9225 >
9226 > for ac_func in strftime
9227 > do
9228 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9229 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9230 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9231 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9232 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9233 > else
9234 >  cat >conftest.$ac_ext <<_ACEOF
9235 > /* confdefs.h.  */
9236 > _ACEOF
9237 > cat confdefs.h >>conftest.$ac_ext
9238 > cat >>conftest.$ac_ext <<_ACEOF
9239 > /* end confdefs.h.  */
9240 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9241 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9242 > #define $ac_func innocuous_$ac_func
9243 >
9244 > /* System header to define __stub macros and hopefully few prototypes,
9245 >    which can conflict with char $ac_func (); below.
9246 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9247 >    <limits.h> exists even on freestanding compilers.  */
9248 >
9249 > #ifdef __STDC__
9250 > # include <limits.h>
9251 > #else
9252 > # include <assert.h>
9253 > #endif
9254 >
9255 > #undef $ac_func
9256 >
9257 > /* Override any gcc2 internal prototype to avoid an error.  */
9258 > #ifdef __cplusplus
9259 > extern "C"
9260 > {
9261 > #endif
9262 > /* We use char because int might match the return type of a gcc2
9263 >   builtin and then its argument prototype would still apply.  */
9264 > char $ac_func ();
9265 > /* The GNU C library defines this for functions which it implements
9266 >    to always fail with ENOSYS.  Some functions are actually named
9267 >    something starting with __ and the normal name is an alias.  */
9268 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9269 > choke me
9270 > #else
9271 > char (*f) () = $ac_func;
9272 > #endif
9273 > #ifdef __cplusplus
9274 > }
9275 > #endif
9276 >
9277 > #ifdef FC_DUMMY_MAIN
9278 > #ifndef FC_DUMMY_MAIN_EQ_F77
9279 > #  ifdef __cplusplus
9280 >     extern "C"
9281 > #  endif
9282 >   int FC_DUMMY_MAIN() { return 1; }
9283 > #endif
9284 > #endif
9285 > int
9286 > main ()
9287 > {
9288 > return f != $ac_func;
9289 >  ;
9290 >  return 0;
9291 > }
9292 > _ACEOF
9293 > rm -f conftest.$ac_objext conftest$ac_exeext
9294 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9295 >  (eval $ac_link) 2>conftest.er1
9296 >  ac_status=$?
9297 >  grep -v '^ *+' conftest.er1 >conftest.err
9298 >  rm -f conftest.er1
9299 >  cat conftest.err >&5
9300 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9301 >  (exit $ac_status); } &&
9302 >         { ac_try='test -z "$ac_c_werror_flag"
9303 >                         || test ! -s conftest.err'
9304 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9305 >  (eval $ac_try) 2>&5
9306 >  ac_status=$?
9307 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9308 >  (exit $ac_status); }; } &&
9309 >         { ac_try='test -s conftest$ac_exeext'
9310 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9311 >  (eval $ac_try) 2>&5
9312 >  ac_status=$?
9313 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9314 >  (exit $ac_status); }; }; then
9315 >  eval "$as_ac_var=yes"
9316 > else
9317 >  echo "$as_me: failed program was:" >&5
9318 > sed 's/^/| /' conftest.$ac_ext >&5
9319 >
9320 > eval "$as_ac_var=no"
9321 > fi
9322 > rm -f conftest.err conftest.$ac_objext \
9323 >      conftest$ac_exeext conftest.$ac_ext
9324 > fi
9325 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9326 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9327 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9328 >  cat >>confdefs.h <<_ACEOF
9329 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9330 > _ACEOF
9331 >
9332 > else
9333 >  # strftime is in -lintl on SCO UNIX.
9334 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9335 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9336 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9337 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9338 > else
9339 >  ac_check_lib_save_LIBS=$LIBS
9340 > LIBS="-lintl  $LIBS"
9341 > cat >conftest.$ac_ext <<_ACEOF
9342 > /* confdefs.h.  */
9343 > _ACEOF
9344 > cat confdefs.h >>conftest.$ac_ext
9345 > cat >>conftest.$ac_ext <<_ACEOF
9346 > /* end confdefs.h.  */
9347 >
9348 > /* Override any gcc2 internal prototype to avoid an error.  */
9349 > #ifdef __cplusplus
9350 > extern "C"
9351 > #endif
9352 > /* We use char because int might match the return type of a gcc2
9353 >   builtin and then its argument prototype would still apply.  */
9354 > char strftime ();
9355 > #ifdef FC_DUMMY_MAIN
9356 > #ifndef FC_DUMMY_MAIN_EQ_F77
9357 > #  ifdef __cplusplus
9358 >     extern "C"
9359 > #  endif
9360 >   int FC_DUMMY_MAIN() { return 1; }
9361 > #endif
9362 > #endif
9363 > int
9364 > main ()
9365 > {
9366 > strftime ();
9367 >  ;
9368 >  return 0;
9369 > }
9370 > _ACEOF
9371 > rm -f conftest.$ac_objext conftest$ac_exeext
9372 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9373 >  (eval $ac_link) 2>conftest.er1
9374 >  ac_status=$?
9375 >  grep -v '^ *+' conftest.er1 >conftest.err
9376 >  rm -f conftest.er1
9377 >  cat conftest.err >&5
9378 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9379 >  (exit $ac_status); } &&
9380 >         { ac_try='test -z "$ac_c_werror_flag"
9381 >                         || test ! -s conftest.err'
9382 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9383 >  (eval $ac_try) 2>&5
9384 >  ac_status=$?
9385 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9386 >  (exit $ac_status); }; } &&
9387 >         { ac_try='test -s conftest$ac_exeext'
9388 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9389 >  (eval $ac_try) 2>&5
9390 >  ac_status=$?
9391 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9392 >  (exit $ac_status); }; }; then
9393 >  ac_cv_lib_intl_strftime=yes
9394 > else
9395 >  echo "$as_me: failed program was:" >&5
9396 > sed 's/^/| /' conftest.$ac_ext >&5
9397 >
9398 > ac_cv_lib_intl_strftime=no
9399 > fi
9400 > rm -f conftest.err conftest.$ac_objext \
9401 >      conftest$ac_exeext conftest.$ac_ext
9402 > LIBS=$ac_check_lib_save_LIBS
9403 > fi
9404 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9405 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9406 > if test $ac_cv_lib_intl_strftime = yes; then
9407 >  cat >>confdefs.h <<\_ACEOF
9408 > #define HAVE_STRFTIME 1
9409 > _ACEOF
9410 >
9411 > LIBS="-lintl $LIBS"
9412 > fi
9413 >
9414 > fi
9415 > done
9416 >
9417 > echo "$as_me:$LINENO: checking for working strtod" >&5
9418 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9419 > if test "${ac_cv_func_strtod+set}" = set; then
9420 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9421 > else
9422 >  if test "$cross_compiling" = yes; then
9423 >  ac_cv_func_strtod=no
9424 > else
9425 >  cat >conftest.$ac_ext <<_ACEOF
9426 > /* confdefs.h.  */
9427 > _ACEOF
9428 > cat confdefs.h >>conftest.$ac_ext
9429 > cat >>conftest.$ac_ext <<_ACEOF
9430 > /* end confdefs.h.  */
9431 >
9432 > double strtod ();
9433 > int
9434 > main()
9435 > {
9436 >  {
9437 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9438 >    char *string = " +69";
9439 >    char *term;
9440 >    double value;
9441 >    value = strtod (string, &term);
9442 >    if (value != 69 || term != (string + 4))
9443 >      exit (1);
9444 >  }
9445 >
9446 >  {
9447 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9448 >       terminating character under some conditions.  */
9449 >    char *string = "NaN";
9450 >    char *term;
9451 >    strtod (string, &term);
9452 >    if (term != string && *(term - 1) == 0)
9453 >      exit (1);
9454 >  }
9455 >  exit (0);
9456 > }
9457 >
9458 > _ACEOF
9459 > rm -f conftest$ac_exeext
9460 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9461 >  (eval $ac_link) 2>&5
9462 >  ac_status=$?
9463 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9464 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9465 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9466 >  (eval $ac_try) 2>&5
9467 >  ac_status=$?
9468 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9469 >  (exit $ac_status); }; }; then
9470 >  ac_cv_func_strtod=yes
9471 > else
9472 >  echo "$as_me: program exited with status $ac_status" >&5
9473 > echo "$as_me: failed program was:" >&5
9474 > sed 's/^/| /' conftest.$ac_ext >&5
9475 >
9476 > ( exit $ac_status )
9477 > ac_cv_func_strtod=no
9478 > fi
9479 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9480 > fi
9481 > fi
9482 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9483 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9484 > if test $ac_cv_func_strtod = no; then
9485 >  case $LIBOBJS in
9486 >    "strtod.$ac_objext"   | \
9487 >  *" strtod.$ac_objext"   | \
9488 >    "strtod.$ac_objext "* | \
9489 >  *" strtod.$ac_objext "* ) ;;
9490 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9491 > esac
9492 >
9493 > echo "$as_me:$LINENO: checking for pow" >&5
9494 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9495 > if test "${ac_cv_func_pow+set}" = set; then
9496 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9497 > else
9498 >  cat >conftest.$ac_ext <<_ACEOF
9499 > /* confdefs.h.  */
9500 > _ACEOF
9501 > cat confdefs.h >>conftest.$ac_ext
9502 > cat >>conftest.$ac_ext <<_ACEOF
9503 > /* end confdefs.h.  */
9504 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9505 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9506 > #define pow innocuous_pow
9507 >
9508 > /* System header to define __stub macros and hopefully few prototypes,
9509 >    which can conflict with char pow (); below.
9510 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9511 >    <limits.h> exists even on freestanding compilers.  */
9512 >
9513 > #ifdef __STDC__
9514 > # include <limits.h>
9515 > #else
9516 > # include <assert.h>
9517 > #endif
9518 >
9519 > #undef pow
9520 >
9521 > /* Override any gcc2 internal prototype to avoid an error.  */
9522 > #ifdef __cplusplus
9523 > extern "C"
9524 > {
9525 > #endif
9526 > /* We use char because int might match the return type of a gcc2
9527 >   builtin and then its argument prototype would still apply.  */
9528 > char pow ();
9529 > /* The GNU C library defines this for functions which it implements
9530 >    to always fail with ENOSYS.  Some functions are actually named
9531 >    something starting with __ and the normal name is an alias.  */
9532 > #if defined (__stub_pow) || defined (__stub___pow)
9533 > choke me
9534 > #else
9535 > char (*f) () = pow;
9536 > #endif
9537 > #ifdef __cplusplus
9538 > }
9539 > #endif
9540 >
9541 > #ifdef FC_DUMMY_MAIN
9542 > #ifndef FC_DUMMY_MAIN_EQ_F77
9543 > #  ifdef __cplusplus
9544 >     extern "C"
9545 > #  endif
9546 >   int FC_DUMMY_MAIN() { return 1; }
9547 > #endif
9548 > #endif
9549 > int
9550 > main ()
9551 > {
9552 > return f != pow;
9553 >  ;
9554 >  return 0;
9555 > }
9556 > _ACEOF
9557 > rm -f conftest.$ac_objext conftest$ac_exeext
9558 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9559 >  (eval $ac_link) 2>conftest.er1
9560 >  ac_status=$?
9561 >  grep -v '^ *+' conftest.er1 >conftest.err
9562 >  rm -f conftest.er1
9563 >  cat conftest.err >&5
9564 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9565 >  (exit $ac_status); } &&
9566 >         { ac_try='test -z "$ac_c_werror_flag"
9567 >                         || test ! -s conftest.err'
9568 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9569 >  (eval $ac_try) 2>&5
9570 >  ac_status=$?
9571 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9572 >  (exit $ac_status); }; } &&
9573 >         { ac_try='test -s conftest$ac_exeext'
9574 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9575 >  (eval $ac_try) 2>&5
9576 >  ac_status=$?
9577 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9578 >  (exit $ac_status); }; }; then
9579 >  ac_cv_func_pow=yes
9580 > else
9581 >  echo "$as_me: failed program was:" >&5
9582 > sed 's/^/| /' conftest.$ac_ext >&5
9583 >
9584 > ac_cv_func_pow=no
9585 > fi
9586 > rm -f conftest.err conftest.$ac_objext \
9587 >      conftest$ac_exeext conftest.$ac_ext
9588 > fi
9589 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9590 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9591 >
9592 > if test $ac_cv_func_pow = no; then
9593 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9594 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9595 > if test "${ac_cv_lib_m_pow+set}" = set; then
9596 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9597 > else
9598 >  ac_check_lib_save_LIBS=$LIBS
9599 > LIBS="-lm  $LIBS"
9600 > cat >conftest.$ac_ext <<_ACEOF
9601 > /* confdefs.h.  */
9602 > _ACEOF
9603 > cat confdefs.h >>conftest.$ac_ext
9604 > cat >>conftest.$ac_ext <<_ACEOF
9605 > /* end confdefs.h.  */
9606 >
9607 > /* Override any gcc2 internal prototype to avoid an error.  */
9608 > #ifdef __cplusplus
9609 > extern "C"
9610 > #endif
9611 > /* We use char because int might match the return type of a gcc2
9612 >   builtin and then its argument prototype would still apply.  */
9613 > char pow ();
9614 > #ifdef FC_DUMMY_MAIN
9615 > #ifndef FC_DUMMY_MAIN_EQ_F77
9616 > #  ifdef __cplusplus
9617 >     extern "C"
9618 > #  endif
9619 >   int FC_DUMMY_MAIN() { return 1; }
9620 > #endif
9621 > #endif
9622 > int
9623 > main ()
9624 > {
9625 > pow ();
9626 >  ;
9627 >  return 0;
9628 > }
9629 > _ACEOF
9630 > rm -f conftest.$ac_objext conftest$ac_exeext
9631 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9632 >  (eval $ac_link) 2>conftest.er1
9633 >  ac_status=$?
9634 >  grep -v '^ *+' conftest.er1 >conftest.err
9635 >  rm -f conftest.er1
9636 >  cat conftest.err >&5
9637 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9638 >  (exit $ac_status); } &&
9639 >         { ac_try='test -z "$ac_c_werror_flag"
9640 >                         || test ! -s conftest.err'
9641 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9642 >  (eval $ac_try) 2>&5
9643 >  ac_status=$?
9644 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9645 >  (exit $ac_status); }; } &&
9646 >         { ac_try='test -s conftest$ac_exeext'
9647 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9648 >  (eval $ac_try) 2>&5
9649 >  ac_status=$?
9650 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9651 >  (exit $ac_status); }; }; then
9652 >  ac_cv_lib_m_pow=yes
9653 > else
9654 >  echo "$as_me: failed program was:" >&5
9655 > sed 's/^/| /' conftest.$ac_ext >&5
9656 >
9657 > ac_cv_lib_m_pow=no
9658 > fi
9659 > rm -f conftest.err conftest.$ac_objext \
9660 >      conftest$ac_exeext conftest.$ac_ext
9661 > LIBS=$ac_check_lib_save_LIBS
9662 > fi
9663 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9664 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9665 > if test $ac_cv_lib_m_pow = yes; then
9666 >  POW_LIB=-lm
9667 > else
9668 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9669 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9670 > fi
9671 >
9672 > fi
9673 >
9674 > fi
9675 >
9676 >
9677 >
9678 >
9679 >
9680 >
9681 >
9682 >
9683 >
9684 >
9685 >
9686 >
9687 >
9688 >
9689 >
9690 >
9691 >
9692 >
9693 >
9694 >
9695 >
9696 >
9697 >
9698 >
9699 >
9700 >
9701 >
9702 >
9703 > for ac_func in floor getpagesize gettimeofday memchr memmove memset pow pstat_getdynamic pstat_getstatic rint select snprintf sranddev sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strrchr strstr strtol sysmp getsysinfo sysctl table
9704 > do
9705 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9706 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9707 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9708 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9709 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9710 > else
9711 >  cat >conftest.$ac_ext <<_ACEOF
9712 > /* confdefs.h.  */
9713 > _ACEOF
9714 > cat confdefs.h >>conftest.$ac_ext
9715 > cat >>conftest.$ac_ext <<_ACEOF
9716 > /* end confdefs.h.  */
9717 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9718 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9719 > #define $ac_func innocuous_$ac_func
9720 >
9721 > /* System header to define __stub macros and hopefully few prototypes,
9722 >    which can conflict with char $ac_func (); below.
9723 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9724 >    <limits.h> exists even on freestanding compilers.  */
9725 >
9726 > #ifdef __STDC__
9727 > # include <limits.h>
9728 > #else
9729 > # include <assert.h>
9730 > #endif
9731 >
9732 > #undef $ac_func
9733 >
9734 > /* Override any gcc2 internal prototype to avoid an error.  */
9735 > #ifdef __cplusplus
9736 > extern "C"
9737 > {
9738 > #endif
9739 > /* We use char because int might match the return type of a gcc2
9740 >   builtin and then its argument prototype would still apply.  */
9741 > char $ac_func ();
9742 > /* The GNU C library defines this for functions which it implements
9743 >    to always fail with ENOSYS.  Some functions are actually named
9744 >    something starting with __ and the normal name is an alias.  */
9745 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9746 > choke me
9747 > #else
9748 > char (*f) () = $ac_func;
9749 > #endif
9750 > #ifdef __cplusplus
9751 > }
9752 > #endif
9753 >
9754 > #ifdef FC_DUMMY_MAIN
9755 > #ifndef FC_DUMMY_MAIN_EQ_F77
9756 > #  ifdef __cplusplus
9757 >     extern "C"
9758 > #  endif
9759 >   int FC_DUMMY_MAIN() { return 1; }
9760 > #endif
9761 > #endif
9762 > int
9763 > main ()
9764 > {
9765 > return f != $ac_func;
9766 >  ;
9767 >  return 0;
9768 > }
9769 > _ACEOF
9770 > rm -f conftest.$ac_objext conftest$ac_exeext
9771 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9772 >  (eval $ac_link) 2>conftest.er1
9773 >  ac_status=$?
9774 >  grep -v '^ *+' conftest.er1 >conftest.err
9775 >  rm -f conftest.er1
9776 >  cat conftest.err >&5
9777 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9778 >  (exit $ac_status); } &&
9779 >         { ac_try='test -z "$ac_c_werror_flag"
9780 >                         || test ! -s conftest.err'
9781 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9782 >  (eval $ac_try) 2>&5
9783 >  ac_status=$?
9784 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9785 >  (exit $ac_status); }; } &&
9786 >         { ac_try='test -s conftest$ac_exeext'
9787 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9788 >  (eval $ac_try) 2>&5
9789 >  ac_status=$?
9790 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9791 >  (exit $ac_status); }; }; then
9792 >  eval "$as_ac_var=yes"
9793 > else
9794 >  echo "$as_me: failed program was:" >&5
9795 > sed 's/^/| /' conftest.$ac_ext >&5
9796 >
9797 > eval "$as_ac_var=no"
9798 > fi
9799 > rm -f conftest.err conftest.$ac_objext \
9800 >      conftest$ac_exeext conftest.$ac_ext
9801 > fi
9802 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9803 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9804 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9805 >  cat >>confdefs.h <<_ACEOF
9806 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9807 > _ACEOF
9808 >
9809 > fi
9810 > done
9811 >
9812 >
9813 > # special check for _system_configuration because AIX <4.3.2 do not
9814 > # contain the `physmem' member.
9815 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9816 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9817 > cat >conftest.$ac_ext <<_ACEOF
9818 > /* confdefs.h.  */
9819 > _ACEOF
9820 > cat confdefs.h >>conftest.$ac_ext
9821 > cat >>conftest.$ac_ext <<_ACEOF
9822 > /* end confdefs.h.  */
9823 > #include <sys/systemcfg.h>
9824 > #ifdef FC_DUMMY_MAIN
9825 > #ifndef FC_DUMMY_MAIN_EQ_F77
9826 > #  ifdef __cplusplus
9827 >     extern "C"
9828 > #  endif
9829 >   int FC_DUMMY_MAIN() { return 1; }
9830 > #endif
9831 > #endif
9832 > int
9833 > main ()
9834 > {
9835 > double x = _system_configuration.physmem;
9836 >  ;
9837 >  return 0;
9838 > }
9839 > _ACEOF
9840 > rm -f conftest.$ac_objext
9841 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9842 >  (eval $ac_compile) 2>conftest.er1
9843 >  ac_status=$?
9844 >  grep -v '^ *+' conftest.er1 >conftest.err
9845 >  rm -f conftest.er1
9846 >  cat conftest.err >&5
9847 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9848 >  (exit $ac_status); } &&
9849 >         { ac_try='test -z "$ac_c_werror_flag"
9850 >                         || test ! -s conftest.err'
9851 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9852 >  (eval $ac_try) 2>&5
9853 >  ac_status=$?
9854 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9855 >  (exit $ac_status); }; } &&
9856 >         { ac_try='test -s conftest.$ac_objext'
9857 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9858 >  (eval $ac_try) 2>&5
9859 >  ac_status=$?
9860 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9861 >  (exit $ac_status); }; }; then
9862 >  echo "$as_me:$LINENO: result: yes" >&5
9863 > echo "${ECHO_T}yes" >&6
9864 >
9865 > cat >>confdefs.h <<\_ACEOF
9866 > #define HAVE__SYSTEM_CONFIGURATION 1
9867 > _ACEOF
9868 >
9869 > else
9870 >  echo "$as_me: failed program was:" >&5
9871 > sed 's/^/| /' conftest.$ac_ext >&5
9872 >
9873 > echo "$as_me:$LINENO: result: no" >&5
9874 > echo "${ECHO_T}no" >&6
9875 > fi
9876 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9877 >
9878 >  # clean out junk possibly left behind by a previous configuration
9879 >  rm -f src/getopt.h
9880 >  # Check for getopt_long support
9881 >
9882 > for ac_header in getopt.h
9883 > do
9884 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9885 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9886 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9887 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9888 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9889 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9890 > fi
9891 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9892 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9893 > else
9894 >  # Is the header compilable?
9895 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9896 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9897 > cat >conftest.$ac_ext <<_ACEOF
9898 > /* confdefs.h.  */
9899 > _ACEOF
9900 > cat confdefs.h >>conftest.$ac_ext
9901 > cat >>conftest.$ac_ext <<_ACEOF
9902 > /* end confdefs.h.  */
9903 > $ac_includes_default
9904 > #include <$ac_header>
9905 > _ACEOF
9906 > rm -f conftest.$ac_objext
9907 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9908 >  (eval $ac_compile) 2>conftest.er1
9909 >  ac_status=$?
9910 >  grep -v '^ *+' conftest.er1 >conftest.err
9911 >  rm -f conftest.er1
9912 >  cat conftest.err >&5
9913 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9914 >  (exit $ac_status); } &&
9915 >         { ac_try='test -z "$ac_c_werror_flag"
9916 >                         || test ! -s conftest.err'
9917 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9918 >  (eval $ac_try) 2>&5
9919 >  ac_status=$?
9920 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9921 >  (exit $ac_status); }; } &&
9922 >         { ac_try='test -s conftest.$ac_objext'
9923 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9924 >  (eval $ac_try) 2>&5
9925 >  ac_status=$?
9926 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9927 >  (exit $ac_status); }; }; then
9928 >  ac_header_compiler=yes
9929 > else
9930 >  echo "$as_me: failed program was:" >&5
9931 > sed 's/^/| /' conftest.$ac_ext >&5
9932 >
9933 > ac_header_compiler=no
9934 > fi
9935 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9936 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9937 > echo "${ECHO_T}$ac_header_compiler" >&6
9938 >
9939 > # Is the header present?
9940 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9941 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9942 > cat >conftest.$ac_ext <<_ACEOF
9943 > /* confdefs.h.  */
9944 > _ACEOF
9945 > cat confdefs.h >>conftest.$ac_ext
9946 > cat >>conftest.$ac_ext <<_ACEOF
9947 > /* end confdefs.h.  */
9948 > #include <$ac_header>
9949 > _ACEOF
9950 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9951 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9952 >  ac_status=$?
9953 >  grep -v '^ *+' conftest.er1 >conftest.err
9954 >  rm -f conftest.er1
9955 >  cat conftest.err >&5
9956 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9957 >  (exit $ac_status); } >/dev/null; then
9958 >  if test -s conftest.err; then
9959 >    ac_cpp_err=$ac_c_preproc_warn_flag
9960 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9961 >  else
9962 >    ac_cpp_err=
9963 >  fi
9964 > else
9965 >  ac_cpp_err=yes
9966 > fi
9967 > if test -z "$ac_cpp_err"; then
9968 >  ac_header_preproc=yes
9969 > else
9970 >  echo "$as_me: failed program was:" >&5
9971 > sed 's/^/| /' conftest.$ac_ext >&5
9972 >
9973 >  ac_header_preproc=no
9974 > fi
9975 > rm -f conftest.err conftest.$ac_ext
9976 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9977 > echo "${ECHO_T}$ac_header_preproc" >&6
9978 >
9979 > # So?  What about this header?
9980 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9981 >  yes:no: )
9982 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9983 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9984 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9985 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9986 >    ac_header_preproc=yes
9987 >    ;;
9988 >  no:yes:* )
9989 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9990 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9991 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9992 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9993 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9994 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9995 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9996 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9997 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9998 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9999 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10000 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10001 >    (
10002 >      cat <<\_ASBOX
10003 > ## ------------------------------ ##
10004 > ## Report this to gezelter@nd.edu ##
10005 > ## ------------------------------ ##
10006 > _ASBOX
10007 >    ) |
10008 >      sed "s/^/$as_me: WARNING:     /" >&2
10009 >    ;;
10010 > esac
10011 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10012 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10013 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10014 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10015 > else
10016 >  eval "$as_ac_Header=\$ac_header_preproc"
10017 > fi
10018 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10019 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10020 >
10021 > fi
10022 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10023 >  cat >>confdefs.h <<_ACEOF
10024 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10025 > _ACEOF
10026 >
10027 > fi
10028 >
10029 > done
10030 >
10031 >
10032 > for ac_func in getopt_long
10033 > do
10034 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10035 > echo "$as_me:$LINENO: checking for $ac_func" >&5
10036 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10037 > if eval "test \"\${$as_ac_var+set}\" = set"; then
10038 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10039 > else
10040 >  cat >conftest.$ac_ext <<_ACEOF
10041 > /* confdefs.h.  */
10042 > _ACEOF
10043 > cat confdefs.h >>conftest.$ac_ext
10044 > cat >>conftest.$ac_ext <<_ACEOF
10045 > /* end confdefs.h.  */
10046 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10047 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10048 > #define $ac_func innocuous_$ac_func
10049 >
10050 > /* System header to define __stub macros and hopefully few prototypes,
10051 >    which can conflict with char $ac_func (); below.
10052 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10053 >    <limits.h> exists even on freestanding compilers.  */
10054 >
10055 > #ifdef __STDC__
10056 > # include <limits.h>
10057 > #else
10058 > # include <assert.h>
10059 > #endif
10060 >
10061 > #undef $ac_func
10062 >
10063 > /* Override any gcc2 internal prototype to avoid an error.  */
10064 > #ifdef __cplusplus
10065 > extern "C"
10066 > {
10067 > #endif
10068 > /* We use char because int might match the return type of a gcc2
10069 >   builtin and then its argument prototype would still apply.  */
10070 > char $ac_func ();
10071 > /* The GNU C library defines this for functions which it implements
10072 >    to always fail with ENOSYS.  Some functions are actually named
10073 >    something starting with __ and the normal name is an alias.  */
10074 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10075 > choke me
10076 > #else
10077 > char (*f) () = $ac_func;
10078 > #endif
10079 > #ifdef __cplusplus
10080 > }
10081 > #endif
10082 >
10083 > #ifdef FC_DUMMY_MAIN
10084 > #ifndef FC_DUMMY_MAIN_EQ_F77
10085 > #  ifdef __cplusplus
10086 >     extern "C"
10087 > #  endif
10088 >   int FC_DUMMY_MAIN() { return 1; }
10089 > #endif
10090 > #endif
10091 > int
10092 > main ()
10093 > {
10094 > return f != $ac_func;
10095 >  ;
10096 >  return 0;
10097 > }
10098 > _ACEOF
10099 > rm -f conftest.$ac_objext conftest$ac_exeext
10100 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10101 >  (eval $ac_link) 2>conftest.er1
10102 >  ac_status=$?
10103 >  grep -v '^ *+' conftest.er1 >conftest.err
10104 >  rm -f conftest.er1
10105 >  cat conftest.err >&5
10106 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10107 >  (exit $ac_status); } &&
10108 >         { ac_try='test -z "$ac_c_werror_flag"
10109 >                         || test ! -s conftest.err'
10110 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10111 >  (eval $ac_try) 2>&5
10112 >  ac_status=$?
10113 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10114 >  (exit $ac_status); }; } &&
10115 >         { ac_try='test -s conftest$ac_exeext'
10116 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10117 >  (eval $ac_try) 2>&5
10118 >  ac_status=$?
10119 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10120 >  (exit $ac_status); }; }; then
10121 >  eval "$as_ac_var=yes"
10122 > else
10123 >  echo "$as_me: failed program was:" >&5
10124 > sed 's/^/| /' conftest.$ac_ext >&5
10125 >
10126 > eval "$as_ac_var=no"
10127 > fi
10128 > rm -f conftest.err conftest.$ac_objext \
10129 >      conftest$ac_exeext conftest.$ac_ext
10130 > fi
10131 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10132 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10133 > if test `eval echo '${'$as_ac_var'}'` = yes; then
10134 >  cat >>confdefs.h <<_ACEOF
10135 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10136 > _ACEOF
10137 >
10138 > else
10139 >  # FreeBSD has a gnugetopt library for this
10140 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
10141 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
10142 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
10143 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10144 > else
10145 >  ac_check_lib_save_LIBS=$LIBS
10146 > LIBS="-lgnugetopt  $LIBS"
10147 > cat >conftest.$ac_ext <<_ACEOF
10148 > /* confdefs.h.  */
10149 > _ACEOF
10150 > cat confdefs.h >>conftest.$ac_ext
10151 > cat >>conftest.$ac_ext <<_ACEOF
10152 > /* end confdefs.h.  */
10153 >
10154 > /* Override any gcc2 internal prototype to avoid an error.  */
10155 > #ifdef __cplusplus
10156 > extern "C"
10157 > #endif
10158 > /* We use char because int might match the return type of a gcc2
10159 >   builtin and then its argument prototype would still apply.  */
10160 > char getopt_long ();
10161 > #ifdef FC_DUMMY_MAIN
10162 > #ifndef FC_DUMMY_MAIN_EQ_F77
10163 > #  ifdef __cplusplus
10164 >     extern "C"
10165 > #  endif
10166 >   int FC_DUMMY_MAIN() { return 1; }
10167 > #endif
10168 > #endif
10169 > int
10170 > main ()
10171 > {
10172 > getopt_long ();
10173 >  ;
10174 >  return 0;
10175 > }
10176 > _ACEOF
10177 > rm -f conftest.$ac_objext conftest$ac_exeext
10178 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10179 >  (eval $ac_link) 2>conftest.er1
10180 >  ac_status=$?
10181 >  grep -v '^ *+' conftest.er1 >conftest.err
10182 >  rm -f conftest.er1
10183 >  cat conftest.err >&5
10184 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10185 >  (exit $ac_status); } &&
10186 >         { ac_try='test -z "$ac_c_werror_flag"
10187 >                         || test ! -s conftest.err'
10188 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10189 >  (eval $ac_try) 2>&5
10190 >  ac_status=$?
10191 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10192 >  (exit $ac_status); }; } &&
10193 >         { ac_try='test -s conftest$ac_exeext'
10194 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10195 >  (eval $ac_try) 2>&5
10196 >  ac_status=$?
10197 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10198 >  (exit $ac_status); }; }; then
10199 >  ac_cv_lib_gnugetopt_getopt_long=yes
10200 > else
10201 >  echo "$as_me: failed program was:" >&5
10202 > sed 's/^/| /' conftest.$ac_ext >&5
10203 >
10204 > ac_cv_lib_gnugetopt_getopt_long=no
10205 > fi
10206 > rm -f conftest.err conftest.$ac_objext \
10207 >      conftest$ac_exeext conftest.$ac_ext
10208 > LIBS=$ac_check_lib_save_LIBS
10209 > fi
10210 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
10211 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
10212 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
10213 >  cat >>confdefs.h <<\_ACEOF
10214 > #define HAVE_GETOPT_LONG 1
10215 > _ACEOF
10216 >
10217 > else
10218 >  # use the GNU replacement
10219 >      case $LIBOBJS in
10220 >    "getopt.$ac_objext"   | \
10221 >  *" getopt.$ac_objext"   | \
10222 >    "getopt.$ac_objext "* | \
10223 >  *" getopt.$ac_objext "* ) ;;
10224 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
10225 > esac
10226 >
10227 >      case $LIBOBJS in
10228 >    "getopt1.$ac_objext"   | \
10229 >  *" getopt1.$ac_objext"   | \
10230 >    "getopt1.$ac_objext "* | \
10231 >  *" getopt1.$ac_objext "* ) ;;
10232 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
10233 > esac
10234 >
10235 >                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
10236 >
10237 > fi
10238 >
10239 > fi
10240 > done
10241 >
10242 >
10243 > ac_ext=cc
10244 > ac_cpp='$CXXCPP $CPPFLAGS'
10245 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10246 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10247 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10248 >
10249 >
10250 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
10251 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
10252 > if test "${ac_cv_cxx_namespaces+set}" = set; then
10253 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10254 > else
10255 >
10256 >
10257 > ac_ext=cc
10258 > ac_cpp='$CXXCPP $CPPFLAGS'
10259 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10260 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10261 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10262 >
10263 > cat >conftest.$ac_ext <<_ACEOF
10264 > /* confdefs.h.  */
10265 > _ACEOF
10266 > cat confdefs.h >>conftest.$ac_ext
10267 > cat >>conftest.$ac_ext <<_ACEOF
10268 > /* end confdefs.h.  */
10269 > namespace Outer { namespace Inner { int i = 0; }}
10270 > #ifdef FC_DUMMY_MAIN
10271 > #ifndef FC_DUMMY_MAIN_EQ_F77
10272 > #  ifdef __cplusplus
10273 >     extern "C"
10274 > #  endif
10275 >   int FC_DUMMY_MAIN() { return 1; }
10276 > #endif
10277 > #endif
10278 > int
10279 > main ()
10280 > {
10281 > using namespace Outer::Inner; return i;
10282 >  ;
10283 >  return 0;
10284 > }
10285 > _ACEOF
10286 > rm -f conftest.$ac_objext
10287 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10288 >  (eval $ac_compile) 2>conftest.er1
10289 >  ac_status=$?
10290 >  grep -v '^ *+' conftest.er1 >conftest.err
10291 >  rm -f conftest.er1
10292 >  cat conftest.err >&5
10293 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10294 >  (exit $ac_status); } &&
10295 >         { ac_try='test -z "$ac_cxx_werror_flag"
10296 >                         || test ! -s conftest.err'
10297 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10298 >  (eval $ac_try) 2>&5
10299    ac_status=$?
10300    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10301 <  (exit $ac_status); } &&
10302 <         { ac_try='test -s conftest.$ac_objext'
10301 >  (exit $ac_status); }; } &&
10302 >         { ac_try='test -s conftest.$ac_objext'
10303    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10304    (eval $ac_try) 2>&5
10305    ac_status=$?
10306    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10307    (exit $ac_status); }; }; then
10308 <  ac_cv_f90_module_names=
4050 < ac_file_list=*
4051 < for ac_file in $ac_file_list; do
4052 <   case $ac_file in
4053 <      # don't care for original source and object files
4054 <      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
4055 <          :
4056 <          ;;
4057 <      # look for new files derived from the file name
4058 <      *conftest*)
4059 <          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
4060 <            ac_exists=false
4061 <  for ac_i in $ac_cv_f90_module_names; do
4062 <    if test x"$ac_pat" = x"$ac_i"; then
4063 <      ac_exists=true
4064 <      break
4065 <    fi
4066 <  done
4067 <
4068 <  if test x"$ac_exists" = xtrue; then
4069 <  :
10308 >  ac_cv_cxx_namespaces=yes
10309   else
4071  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4072 fi
4073
4074          ;;
4075      # look for new files derived from the module name,
4076      # with different case translation schemes
4077      *Bar*)
4078          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
4079            ac_exists=false
4080  for ac_i in $ac_cv_f90_module_names; do
4081    if test x"$ac_pat" = x"$ac_i"; then
4082      ac_exists=true
4083      break
4084    fi
4085  done
4086
4087  if test x"$ac_exists" = xtrue; then
4088  :
4089 else
4090  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4091 fi
4092
4093          ;;
4094      *bar*)
4095          ac_pat=`echo $ac_file | sed s/bar/%module%/`
4096            ac_exists=false
4097  for ac_i in $ac_cv_f90_module_names; do
4098    if test x"$ac_pat" = x"$ac_i"; then
4099      ac_exists=true
4100      break
4101    fi
4102  done
4103
4104  if test x"$ac_exists" = xtrue; then
4105  :
4106 else
4107  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4108 fi
4109
4110          ;;
4111      *BAR*)
4112          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
4113            ac_exists=false
4114  for ac_i in $ac_cv_f90_module_names; do
4115    if test x"$ac_pat" = x"$ac_i"; then
4116      ac_exists=true
4117      break
4118    fi
4119  done
4120
4121  if test x"$ac_exists" = xtrue; then
4122  :
4123 else
4124  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4125 fi
4126
4127          ;;
4128       # Other files - we have no idea how they are generated
4129       *)
4130          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
4131 echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
4132          ;;
4133   esac
4134 done
4135 if test "x$ac_cv_f90_module_names" = "x"; then
4136  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4137 echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4138 fi
4139
4140 else
10310    echo "$as_me: failed program was:" >&5
10311   sed 's/^/| /' conftest.$ac_ext >&5
10312  
10313 < ac_cv_f90_module_names=
4145 < { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4146 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
10313 > ac_cv_cxx_namespaces=no
10314   fi
10315 < rm -f conftest.$ac_objext conftest.$ac_ext
10316 < cd ..
10317 < # cleanup
10318 < rm -rf conftest
10319 < ac_ext=f90
10320 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4154 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4155 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
10315 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10316 > ac_ext=cc
10317 > ac_cpp='$CXXCPP $CPPFLAGS'
10318 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10319 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10320 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10321  
4157 fi
4158 echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
4159 echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
10322  
4161 # We now generate a shell script that will help us to figure out the correct
4162 # module file names, using the value of ac_cv_f90_module_names
4163
4164 echo "Generating shell script modnam"
4165
4166 cat > scripts/modnam << EOF
4167 #! /bin/sh
4168 # This script is auto-generated by configure
4169 #
4170 usage="\\
4171 Usage: \$0 [FILES]
4172
4173 [FILES] are Fortran 90 source files.
4174 The output is a list of module file names that the Fortran 90 compiler
4175 generates when compiling [FILES]."
4176
4177 list=
4178 empty=
4179
4180 if test \$# -eq 0; then
4181   echo "\$usage"; exit 0
10323   fi
10324 + echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10325 + echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10326 + if test "$ac_cv_cxx_namespaces" = yes; then
10327  
10328 < while test \$# != 0; do
10328 > cat >>confdefs.h <<\_ACEOF
10329 > #define HAVE_NAMESPACES
10330 > _ACEOF
10331  
4186  file=\$1
4187  shift
4188
4189 # strip suffix
4190  base=\`echo \$file | sed 's/[.][^.]*$//'\`
4191
4192  test ! -f \$file && continue
4193
4194 # Look for module definitions and transform them to upper / lower case
4195  mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
4196  upper=\`echo \$mods | tr a-z A-Z\`
4197  lower=\`echo \$mods | tr A-Z a-z\`
4198
4199 # Here, the patterns for generating module file names were inserted by configure
4200  for trans in $ac_cv_f90_module_names; do
4201
4202    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
4203    var=empty
4204    case \$pat in
4205       %MODULE%)
4206          var=upper ;;
4207       %Module%)
4208          var=mods ;;
4209       %module%)
4210          var=lower ;;
4211       %FILE%)
4212          test -n "\$mods" && var=base ;;
4213    esac
4214    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
4215    list="\$list \$new"
4216  done
4217 done
4218
4219 echo \$list
4220 # end of configure-generated script
4221 EOF
4222 chmod 755 scripts/modnam
4223
4224 pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
4225 F90_MODULE_NAMES=empty
4226 case $pat in
4227       %MODULE%)
4228          F90_MODULE_NAMES=UPPER ;;
4229       %Module%)
4230          F90_MODULE_NAMES=Mixed ;;
4231       %module%)
4232          F90_MODULE_NAMES=lower ;;
4233       *)
4234          F90_MODULE_NAMES=unknown ;;
4235 esac
4236
4237 ac_ext=c
4238 ac_cpp='$CPP $CPPFLAGS'
4239 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4240 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4241 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4242
4243
4244 ac_ext=c
4245 ac_cpp='$CPP $CPPFLAGS'
4246 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4247 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4248 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4249
4250 ac_ext=c
4251 ac_cpp='$CPP $CPPFLAGS'
4252 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4253 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4254 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4255 echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4256 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4257 # On Suns, sometimes $CPP names a directory.
4258 if test -n "$CPP" && test -d "$CPP"; then
4259  CPP=
10332   fi
10333 < if test -z "$CPP"; then
10334 <  if test "${ac_cv_prog_CPP+set}" = set; then
10333 >
10334 > ac_ext=cc
10335 > ac_cpp='$CXXCPP $CPPFLAGS'
10336 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10337 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10338 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10339 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10340 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10341 > if test -z "$CXXCPP"; then
10342 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10343    echo $ECHO_N "(cached) $ECHO_C" >&6
10344   else
10345 <      # Double quotes because CPP needs to be expanded
10346 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
10345 >      # Double quotes because CXXCPP needs to be expanded
10346 >    for CXXCPP in "$CXX -E" "/lib/cpp"
10347      do
10348        ac_preproc_ok=false
10349 < for ac_c_preproc_warn_flag in '' yes
10349 > for ac_cxx_preproc_warn_flag in '' yes
10350   do
10351    # Use a header file that comes with gcc, so configuring glibc
10352    # with a fresh cross-compiler works.
# Line 4275 | Line 10355 | do
10355    # On the NeXT, cc -E runs the code through the compiler's parser,
10356    # not just through cpp. "Syntax error" is here to catch this case.
10357    cat >conftest.$ac_ext <<_ACEOF
4278 #line $LINENO "configure"
10358   /* confdefs.h.  */
10359   _ACEOF
10360   cat confdefs.h >>conftest.$ac_ext
# Line 4286 | Line 10365 | cat >>conftest.$ac_ext <<_ACEOF
10365   #else
10366   # include <assert.h>
10367   #endif
10368 <                     Syntax error
10368 >                     Syntax error
10369   _ACEOF
10370   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10371    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 4297 | Line 10376 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10376    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10377    (exit $ac_status); } >/dev/null; then
10378    if test -s conftest.err; then
10379 <    ac_cpp_err=$ac_c_preproc_warn_flag
10379 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10380 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10381    else
10382      ac_cpp_err=
10383    fi
# Line 4318 | Line 10398 | rm -f conftest.err conftest.$ac_ext
10398    # OK, works on sane cases.  Now check whether non-existent headers
10399    # can be detected and how.
10400    cat >conftest.$ac_ext <<_ACEOF
4321 #line $LINENO "configure"
10401   /* confdefs.h.  */
10402   _ACEOF
10403   cat confdefs.h >>conftest.$ac_ext
# Line 4335 | Line 10414 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10414    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10415    (exit $ac_status); } >/dev/null; then
10416    if test -s conftest.err; then
10417 <    ac_cpp_err=$ac_c_preproc_warn_flag
10417 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10418 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10419    else
10420      ac_cpp_err=
10421    fi
# Line 4363 | Line 10443 | fi
10443   fi
10444  
10445      done
10446 <    ac_cv_prog_CPP=$CPP
10446 >    ac_cv_prog_CXXCPP=$CXXCPP
10447  
10448   fi
10449 <  CPP=$ac_cv_prog_CPP
10449 >  CXXCPP=$ac_cv_prog_CXXCPP
10450   else
10451 <  ac_cv_prog_CPP=$CPP
10451 >  ac_cv_prog_CXXCPP=$CXXCPP
10452   fi
10453 < echo "$as_me:$LINENO: result: $CPP" >&5
10454 < echo "${ECHO_T}$CPP" >&6
10453 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10454 > echo "${ECHO_T}$CXXCPP" >&6
10455   ac_preproc_ok=false
10456 < for ac_c_preproc_warn_flag in '' yes
10456 > for ac_cxx_preproc_warn_flag in '' yes
10457   do
10458    # Use a header file that comes with gcc, so configuring glibc
10459    # with a fresh cross-compiler works.
# Line 4382 | Line 10462 | do
10462    # On the NeXT, cc -E runs the code through the compiler's parser,
10463    # not just through cpp. "Syntax error" is here to catch this case.
10464    cat >conftest.$ac_ext <<_ACEOF
4385 #line $LINENO "configure"
10465   /* confdefs.h.  */
10466   _ACEOF
10467   cat confdefs.h >>conftest.$ac_ext
# Line 4393 | Line 10472 | cat >>conftest.$ac_ext <<_ACEOF
10472   #else
10473   # include <assert.h>
10474   #endif
10475 <                     Syntax error
10475 >                     Syntax error
10476   _ACEOF
10477   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10478    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 4404 | Line 10483 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10483    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10484    (exit $ac_status); } >/dev/null; then
10485    if test -s conftest.err; then
10486 <    ac_cpp_err=$ac_c_preproc_warn_flag
10486 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10487 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10488    else
10489      ac_cpp_err=
10490    fi
# Line 4425 | Line 10505 | rm -f conftest.err conftest.$ac_ext
10505    # OK, works on sane cases.  Now check whether non-existent headers
10506    # can be detected and how.
10507    cat >conftest.$ac_ext <<_ACEOF
4428 #line $LINENO "configure"
10508   /* confdefs.h.  */
10509   _ACEOF
10510   cat confdefs.h >>conftest.$ac_ext
# Line 4442 | Line 10521 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10521    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10522    (exit $ac_status); } >/dev/null; then
10523    if test -s conftest.err; then
10524 <    ac_cpp_err=$ac_c_preproc_warn_flag
10524 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10525 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10526    else
10527      ac_cpp_err=
10528    fi
# Line 4468 | Line 10548 | else
10548   if $ac_preproc_ok; then
10549    :
10550   else
10551 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
10551 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10552   See \`config.log' for more details." >&5
10553 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
10553 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10554   See \`config.log' for more details." >&2;}
10555     { (exit 1); exit 1; }; }
10556   fi
10557  
10558 < ac_ext=c
10559 < ac_cpp='$CPP $CPPFLAGS'
10560 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10561 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10562 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
10558 > ac_ext=cc
10559 > ac_cpp='$CXXCPP $CPPFLAGS'
10560 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10561 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10562 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10563  
10564  
10565 < echo "$as_me:$LINENO: checking for egrep" >&5
10566 < echo $ECHO_N "checking for egrep... $ECHO_C" >&6
10567 < if test "${ac_cv_prog_egrep+set}" = set; then
10565 > echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10566 > echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10567 > if test "${ac_cv_cxx_have_stl+set}" = set; then
10568    echo $ECHO_N "(cached) $ECHO_C" >&6
10569   else
4490  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4491    then ac_cv_prog_egrep='grep -E'
4492    else ac_cv_prog_egrep='egrep'
4493    fi
4494 fi
4495 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
4496 echo "${ECHO_T}$ac_cv_prog_egrep" >&6
4497 EGREP=$ac_cv_prog_egrep
10570  
10571  
10572 < echo "$as_me:$LINENO: checking for ANSI C header files" >&5
10573 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
10574 < if test "${ac_cv_header_stdc+set}" = set; then
10575 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10576 < else
10577 <  cat >conftest.$ac_ext <<_ACEOF
10578 < #line $LINENO "configure"
10572 >
10573 > ac_ext=cc
10574 > ac_cpp='$CXXCPP $CPPFLAGS'
10575 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10576 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10577 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10578 >
10579 > cat >conftest.$ac_ext <<_ACEOF
10580   /* confdefs.h.  */
10581   _ACEOF
10582   cat confdefs.h >>conftest.$ac_ext
10583   cat >>conftest.$ac_ext <<_ACEOF
10584   /* end confdefs.h.  */
10585 < #include <stdlib.h>
10586 < #include <stdarg.h>
10587 < #include <string.h>
10588 < #include <float.h>
10589 <
10585 > #include <list>
10586 > #include <deque>
10587 > #ifdef HAVE_NAMESPACES
10588 > using namespace std;
10589 > #endif
10590 > #ifdef FC_DUMMY_MAIN
10591 > #ifndef FC_DUMMY_MAIN_EQ_F77
10592 > #  ifdef __cplusplus
10593 >     extern "C"
10594 > #  endif
10595 >   int FC_DUMMY_MAIN() { return 1; }
10596 > #endif
10597 > #endif
10598   int
10599   main ()
10600   {
10601 <
10601 > list<int> x; x.push_back(5);
10602 > list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10603    ;
10604    return 0;
10605   }
10606   _ACEOF
10607   rm -f conftest.$ac_objext
10608   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10609 <  (eval $ac_compile) 2>&5
10609 >  (eval $ac_compile) 2>conftest.er1
10610    ac_status=$?
10611 +  grep -v '^ *+' conftest.er1 >conftest.err
10612 +  rm -f conftest.er1
10613 +  cat conftest.err >&5
10614    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10615    (exit $ac_status); } &&
10616 <         { ac_try='test -s conftest.$ac_objext'
10616 >         { ac_try='test -z "$ac_cxx_werror_flag"
10617 >                         || test ! -s conftest.err'
10618    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10619    (eval $ac_try) 2>&5
10620    ac_status=$?
10621    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10622 +  (exit $ac_status); }; } &&
10623 +         { ac_try='test -s conftest.$ac_objext'
10624 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10625 +  (eval $ac_try) 2>&5
10626 +  ac_status=$?
10627 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10628    (exit $ac_status); }; }; then
10629 <  ac_cv_header_stdc=yes
10629 >  ac_cv_cxx_have_stl=yes
10630   else
10631    echo "$as_me: failed program was:" >&5
10632   sed 's/^/| /' conftest.$ac_ext >&5
10633  
10634 < ac_cv_header_stdc=no
10634 > ac_cv_cxx_have_stl=no
10635   fi
10636 < rm -f conftest.$ac_objext conftest.$ac_ext
10636 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10637 > ac_ext=cc
10638 > ac_cpp='$CXXCPP $CPPFLAGS'
10639 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10640 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10641 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10642  
4546 if test $ac_cv_header_stdc = yes; then
4547  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
4548  cat >conftest.$ac_ext <<_ACEOF
4549 #line $LINENO "configure"
4550 /* confdefs.h.  */
4551 _ACEOF
4552 cat confdefs.h >>conftest.$ac_ext
4553 cat >>conftest.$ac_ext <<_ACEOF
4554 /* end confdefs.h.  */
4555 #include <string.h>
10643  
4557 _ACEOF
4558 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
4559  $EGREP "memchr" >/dev/null 2>&1; then
4560  :
4561 else
4562  ac_cv_header_stdc=no
10644   fi
10645 < rm -f conftest*
10645 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10646 > echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10647 > if test "$ac_cv_cxx_have_stl" = yes; then
10648 >
10649 > cat >>confdefs.h <<\_ACEOF
10650 > #define HAVE_STL
10651 > _ACEOF
10652  
10653   fi
10654  
10655 < if test $ac_cv_header_stdc = yes; then
10656 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
10657 <  cat >conftest.$ac_ext <<_ACEOF
10658 < #line $LINENO "configure"
10655 >
10656 >
10657 >  if test "${ac_cv_header_iostream+set}" = set; then
10658 >  echo "$as_me:$LINENO: checking for iostream" >&5
10659 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10660 > if test "${ac_cv_header_iostream+set}" = set; then
10661 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10662 > fi
10663 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10664 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10665 > else
10666 >  # Is the header compilable?
10667 > echo "$as_me:$LINENO: checking iostream usability" >&5
10668 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10669 > cat >conftest.$ac_ext <<_ACEOF
10670   /* confdefs.h.  */
10671   _ACEOF
10672   cat confdefs.h >>conftest.$ac_ext
10673   cat >>conftest.$ac_ext <<_ACEOF
10674   /* end confdefs.h.  */
10675 < #include <stdlib.h>
10675 > $ac_includes_default
10676 > #include <iostream>
10677 > _ACEOF
10678 > rm -f conftest.$ac_objext
10679 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10680 >  (eval $ac_compile) 2>conftest.er1
10681 >  ac_status=$?
10682 >  grep -v '^ *+' conftest.er1 >conftest.err
10683 >  rm -f conftest.er1
10684 >  cat conftest.err >&5
10685 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10686 >  (exit $ac_status); } &&
10687 >         { ac_try='test -z "$ac_cxx_werror_flag"
10688 >                         || test ! -s conftest.err'
10689 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10690 >  (eval $ac_try) 2>&5
10691 >  ac_status=$?
10692 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10693 >  (exit $ac_status); }; } &&
10694 >         { ac_try='test -s conftest.$ac_objext'
10695 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10696 >  (eval $ac_try) 2>&5
10697 >  ac_status=$?
10698 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10699 >  (exit $ac_status); }; }; then
10700 >  ac_header_compiler=yes
10701 > else
10702 >  echo "$as_me: failed program was:" >&5
10703 > sed 's/^/| /' conftest.$ac_ext >&5
10704  
10705 + ac_header_compiler=no
10706 + fi
10707 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10708 + echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10709 + echo "${ECHO_T}$ac_header_compiler" >&6
10710 +
10711 + # Is the header present?
10712 + echo "$as_me:$LINENO: checking iostream presence" >&5
10713 + echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10714 + cat >conftest.$ac_ext <<_ACEOF
10715 + /* confdefs.h.  */
10716   _ACEOF
10717 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
10718 <  $EGREP "free" >/dev/null 2>&1; then
10719 <  :
10717 > cat confdefs.h >>conftest.$ac_ext
10718 > cat >>conftest.$ac_ext <<_ACEOF
10719 > /* end confdefs.h.  */
10720 > #include <iostream>
10721 > _ACEOF
10722 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10723 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10724 >  ac_status=$?
10725 >  grep -v '^ *+' conftest.er1 >conftest.err
10726 >  rm -f conftest.er1
10727 >  cat conftest.err >&5
10728 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10729 >  (exit $ac_status); } >/dev/null; then
10730 >  if test -s conftest.err; then
10731 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10732 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10733 >  else
10734 >    ac_cpp_err=
10735 >  fi
10736   else
10737 <  ac_cv_header_stdc=no
10737 >  ac_cpp_err=yes
10738   fi
10739 < rm -f conftest*
10739 > if test -z "$ac_cpp_err"; then
10740 >  ac_header_preproc=yes
10741 > else
10742 >  echo "$as_me: failed program was:" >&5
10743 > sed 's/^/| /' conftest.$ac_ext >&5
10744  
10745 +  ac_header_preproc=no
10746   fi
10747 + rm -f conftest.err conftest.$ac_ext
10748 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10749 + echo "${ECHO_T}$ac_header_preproc" >&6
10750  
10751 < if test $ac_cv_header_stdc = yes; then
10752 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
10753 <  if test "$cross_compiling" = yes; then
10754 <  :
10751 > # So?  What about this header?
10752 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10753 >  yes:no: )
10754 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10755 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10756 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10757 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10758 >    ac_header_preproc=yes
10759 >    ;;
10760 >  no:yes:* )
10761 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10762 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10763 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10764 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10765 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10766 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10767 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10768 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10769 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10770 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10771 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10772 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10773 >    (
10774 >      cat <<\_ASBOX
10775 > ## ------------------------------ ##
10776 > ## Report this to gezelter@nd.edu ##
10777 > ## ------------------------------ ##
10778 > _ASBOX
10779 >    ) |
10780 >      sed "s/^/$as_me: WARNING:     /" >&2
10781 >    ;;
10782 > esac
10783 > echo "$as_me:$LINENO: checking for iostream" >&5
10784 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10785 > if test "${ac_cv_header_iostream+set}" = set; then
10786 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10787   else
10788 <  cat >conftest.$ac_ext <<_ACEOF
10789 < #line $LINENO "configure"
10788 >  ac_cv_header_iostream=$ac_header_preproc
10789 > fi
10790 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10791 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10792 >
10793 > fi
10794 > if test $ac_cv_header_iostream = yes; then
10795 >
10796 >
10797 > cat >>confdefs.h <<\_ACEOF
10798 > #define HAVE_IOSTREAM 1
10799 > _ACEOF
10800 >
10801 >
10802 > else
10803 >
10804 >
10805 > for ac_header in iostream.h
10806 > do
10807 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10808 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10809 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10810 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10811 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10812 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10813 > fi
10814 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10815 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10816 > else
10817 >  # Is the header compilable?
10818 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10819 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10820 > cat >conftest.$ac_ext <<_ACEOF
10821   /* confdefs.h.  */
10822   _ACEOF
10823   cat confdefs.h >>conftest.$ac_ext
10824   cat >>conftest.$ac_ext <<_ACEOF
10825   /* end confdefs.h.  */
10826 < #include <ctype.h>
10827 < #if ((' ' & 0x0FF) == 0x020)
4604 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4605 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
4606 < #else
4607 < # define ISLOWER(c) \
4608 <                   (('a' <= (c) && (c) <= 'i') \
4609 <                     || ('j' <= (c) && (c) <= 'r') \
4610 <                     || ('s' <= (c) && (c) <= 'z'))
4611 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
4612 < #endif
4613 <
4614 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
4615 < int
4616 < main ()
4617 < {
4618 <  int i;
4619 <  for (i = 0; i < 256; i++)
4620 <    if (XOR (islower (i), ISLOWER (i))
4621 <        || toupper (i) != TOUPPER (i))
4622 <      exit(2);
4623 <  exit (0);
4624 < }
10826 > $ac_includes_default
10827 > #include <$ac_header>
10828   _ACEOF
10829 < rm -f conftest$ac_exeext
10830 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10831 <  (eval $ac_link) 2>&5
10829 > rm -f conftest.$ac_objext
10830 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10831 >  (eval $ac_compile) 2>conftest.er1
10832    ac_status=$?
10833 +  grep -v '^ *+' conftest.er1 >conftest.err
10834 +  rm -f conftest.er1
10835 +  cat conftest.err >&5
10836    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10837 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
10837 >  (exit $ac_status); } &&
10838 >         { ac_try='test -z "$ac_cxx_werror_flag"
10839 >                         || test ! -s conftest.err'
10840    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10841    (eval $ac_try) 2>&5
10842    ac_status=$?
10843    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10844 +  (exit $ac_status); }; } &&
10845 +         { ac_try='test -s conftest.$ac_objext'
10846 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10847 +  (eval $ac_try) 2>&5
10848 +  ac_status=$?
10849 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10850    (exit $ac_status); }; }; then
10851 <  :
10851 >  ac_header_compiler=yes
10852   else
10853 <  echo "$as_me: program exited with status $ac_status" >&5
4640 < echo "$as_me: failed program was:" >&5
10853 >  echo "$as_me: failed program was:" >&5
10854   sed 's/^/| /' conftest.$ac_ext >&5
10855  
10856 < ( exit $ac_status )
4644 < ac_cv_header_stdc=no
10856 > ac_header_compiler=no
10857   fi
10858 < rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
10858 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10859 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10860 > echo "${ECHO_T}$ac_header_compiler" >&6
10861 >
10862 > # Is the header present?
10863 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10864 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10865 > cat >conftest.$ac_ext <<_ACEOF
10866 > /* confdefs.h.  */
10867 > _ACEOF
10868 > cat confdefs.h >>conftest.$ac_ext
10869 > cat >>conftest.$ac_ext <<_ACEOF
10870 > /* end confdefs.h.  */
10871 > #include <$ac_header>
10872 > _ACEOF
10873 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10874 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10875 >  ac_status=$?
10876 >  grep -v '^ *+' conftest.er1 >conftest.err
10877 >  rm -f conftest.er1
10878 >  cat conftest.err >&5
10879 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10880 >  (exit $ac_status); } >/dev/null; then
10881 >  if test -s conftest.err; then
10882 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10883 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10884 >  else
10885 >    ac_cpp_err=
10886 >  fi
10887 > else
10888 >  ac_cpp_err=yes
10889   fi
10890 + if test -z "$ac_cpp_err"; then
10891 +  ac_header_preproc=yes
10892 + else
10893 +  echo "$as_me: failed program was:" >&5
10894 + sed 's/^/| /' conftest.$ac_ext >&5
10895 +
10896 +  ac_header_preproc=no
10897   fi
10898 + rm -f conftest.err conftest.$ac_ext
10899 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10900 + echo "${ECHO_T}$ac_header_preproc" >&6
10901 +
10902 + # So?  What about this header?
10903 + case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10904 +  yes:no: )
10905 +    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10906 + echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10907 +    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10908 + echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10909 +    ac_header_preproc=yes
10910 +    ;;
10911 +  no:yes:* )
10912 +    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10913 + echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10914 +    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10915 + echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10916 +    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10917 + echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10918 +    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10919 + echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10920 +    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10921 + echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10922 +    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10923 + echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10924 +    (
10925 +      cat <<\_ASBOX
10926 + ## ------------------------------ ##
10927 + ## Report this to gezelter@nd.edu ##
10928 + ## ------------------------------ ##
10929 + _ASBOX
10930 +    ) |
10931 +      sed "s/^/$as_me: WARNING:     /" >&2
10932 +    ;;
10933 + esac
10934 + echo "$as_me:$LINENO: checking for $ac_header" >&5
10935 + echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10936 + if eval "test \"\${$as_ac_Header+set}\" = set"; then
10937 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10938 + else
10939 +  eval "$as_ac_Header=\$ac_header_preproc"
10940   fi
10941 < echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
10942 < echo "${ECHO_T}$ac_cv_header_stdc" >&6
4652 < if test $ac_cv_header_stdc = yes; then
10941 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10942 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10943  
10944 < cat >>confdefs.h <<\_ACEOF
10945 < #define STDC_HEADERS 1
10944 > fi
10945 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10946 >  cat >>confdefs.h <<_ACEOF
10947 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10948   _ACEOF
10949  
10950   fi
10951  
10952 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
10952 > done
10953  
10954  
10955 + fi
10956  
10957  
10958  
10959  
10960 +  if test "${ac_cv_header_iomanip+set}" = set; then
10961 +  echo "$as_me:$LINENO: checking for iomanip" >&5
10962 + echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10963 + if test "${ac_cv_header_iomanip+set}" = set; then
10964 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10965 + fi
10966 + echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10967 + echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10968 + else
10969 +  # Is the header compilable?
10970 + echo "$as_me:$LINENO: checking iomanip usability" >&5
10971 + echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10972 + cat >conftest.$ac_ext <<_ACEOF
10973 + /* confdefs.h.  */
10974 + _ACEOF
10975 + cat confdefs.h >>conftest.$ac_ext
10976 + cat >>conftest.$ac_ext <<_ACEOF
10977 + /* end confdefs.h.  */
10978 + $ac_includes_default
10979 + #include <iomanip>
10980 + _ACEOF
10981 + rm -f conftest.$ac_objext
10982 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10983 +  (eval $ac_compile) 2>conftest.er1
10984 +  ac_status=$?
10985 +  grep -v '^ *+' conftest.er1 >conftest.err
10986 +  rm -f conftest.er1
10987 +  cat conftest.err >&5
10988 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10989 +  (exit $ac_status); } &&
10990 +         { ac_try='test -z "$ac_cxx_werror_flag"
10991 +                         || test ! -s conftest.err'
10992 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10993 +  (eval $ac_try) 2>&5
10994 +  ac_status=$?
10995 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10996 +  (exit $ac_status); }; } &&
10997 +         { ac_try='test -s conftest.$ac_objext'
10998 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10999 +  (eval $ac_try) 2>&5
11000 +  ac_status=$?
11001 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11002 +  (exit $ac_status); }; }; then
11003 +  ac_header_compiler=yes
11004 + else
11005 +  echo "$as_me: failed program was:" >&5
11006 + sed 's/^/| /' conftest.$ac_ext >&5
11007  
11008 + ac_header_compiler=no
11009 + fi
11010 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11011 + echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11012 + echo "${ECHO_T}$ac_header_compiler" >&6
11013  
11014 + # Is the header present?
11015 + echo "$as_me:$LINENO: checking iomanip presence" >&5
11016 + echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
11017 + cat >conftest.$ac_ext <<_ACEOF
11018 + /* confdefs.h.  */
11019 + _ACEOF
11020 + cat confdefs.h >>conftest.$ac_ext
11021 + cat >>conftest.$ac_ext <<_ACEOF
11022 + /* end confdefs.h.  */
11023 + #include <iomanip>
11024 + _ACEOF
11025 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11026 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11027 +  ac_status=$?
11028 +  grep -v '^ *+' conftest.er1 >conftest.err
11029 +  rm -f conftest.er1
11030 +  cat conftest.err >&5
11031 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11032 +  (exit $ac_status); } >/dev/null; then
11033 +  if test -s conftest.err; then
11034 +    ac_cpp_err=$ac_cxx_preproc_warn_flag
11035 +    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11036 +  else
11037 +    ac_cpp_err=
11038 +  fi
11039 + else
11040 +  ac_cpp_err=yes
11041 + fi
11042 + if test -z "$ac_cpp_err"; then
11043 +  ac_header_preproc=yes
11044 + else
11045 +  echo "$as_me: failed program was:" >&5
11046 + sed 's/^/| /' conftest.$ac_ext >&5
11047  
11048 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
11049 <                  inttypes.h stdint.h unistd.h
11048 >  ac_header_preproc=no
11049 > fi
11050 > rm -f conftest.err conftest.$ac_ext
11051 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11052 > echo "${ECHO_T}$ac_header_preproc" >&6
11053 >
11054 > # So?  What about this header?
11055 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11056 >  yes:no: )
11057 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
11058 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
11059 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
11060 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
11061 >    ac_header_preproc=yes
11062 >    ;;
11063 >  no:yes:* )
11064 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
11065 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
11066 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
11067 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
11068 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
11069 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
11070 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
11071 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
11072 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
11073 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
11074 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
11075 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
11076 >    (
11077 >      cat <<\_ASBOX
11078 > ## ------------------------------ ##
11079 > ## Report this to gezelter@nd.edu ##
11080 > ## ------------------------------ ##
11081 > _ASBOX
11082 >    ) |
11083 >      sed "s/^/$as_me: WARNING:     /" >&2
11084 >    ;;
11085 > esac
11086 > echo "$as_me:$LINENO: checking for iomanip" >&5
11087 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
11088 > if test "${ac_cv_header_iomanip+set}" = set; then
11089 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11090 > else
11091 >  ac_cv_header_iomanip=$ac_header_preproc
11092 > fi
11093 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
11094 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
11095 >
11096 > fi
11097 > if test $ac_cv_header_iomanip = yes; then
11098 >
11099 >
11100 > cat >>confdefs.h <<\_ACEOF
11101 > #define HAVE_IOMANIP 1
11102 > _ACEOF
11103 >
11104 >
11105 > else
11106 >
11107 >
11108 > for ac_header in iomanip.h
11109   do
11110   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11111 < echo "$as_me:$LINENO: checking for $ac_header" >&5
11111 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11112 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
11113   echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11114   if eval "test \"\${$as_ac_Header+set}\" = set"; then
11115    echo $ECHO_N "(cached) $ECHO_C" >&6
11116 + fi
11117 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11118 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11119   else
11120 <  cat >conftest.$ac_ext <<_ACEOF
11121 < #line $LINENO "configure"
11120 >  # Is the header compilable?
11121 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
11122 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11123 > cat >conftest.$ac_ext <<_ACEOF
11124   /* confdefs.h.  */
11125   _ACEOF
11126   cat confdefs.h >>conftest.$ac_ext
11127   cat >>conftest.$ac_ext <<_ACEOF
11128   /* end confdefs.h.  */
11129   $ac_includes_default
4687
11130   #include <$ac_header>
11131   _ACEOF
11132   rm -f conftest.$ac_objext
11133   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11134 <  (eval $ac_compile) 2>&5
11134 >  (eval $ac_compile) 2>conftest.er1
11135    ac_status=$?
11136 +  grep -v '^ *+' conftest.er1 >conftest.err
11137 +  rm -f conftest.er1
11138 +  cat conftest.err >&5
11139    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11140    (exit $ac_status); } &&
11141 <         { ac_try='test -s conftest.$ac_objext'
11141 >         { ac_try='test -z "$ac_cxx_werror_flag"
11142 >                         || test ! -s conftest.err'
11143    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11144    (eval $ac_try) 2>&5
11145    ac_status=$?
11146    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11147 +  (exit $ac_status); }; } &&
11148 +         { ac_try='test -s conftest.$ac_objext'
11149 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11150 +  (eval $ac_try) 2>&5
11151 +  ac_status=$?
11152 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11153    (exit $ac_status); }; }; then
11154 <  eval "$as_ac_Header=yes"
11154 >  ac_header_compiler=yes
11155 > else
11156 >  echo "$as_me: failed program was:" >&5
11157 > sed 's/^/| /' conftest.$ac_ext >&5
11158 >
11159 > ac_header_compiler=no
11160 > fi
11161 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11162 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11163 > echo "${ECHO_T}$ac_header_compiler" >&6
11164 >
11165 > # Is the header present?
11166 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
11167 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11168 > cat >conftest.$ac_ext <<_ACEOF
11169 > /* confdefs.h.  */
11170 > _ACEOF
11171 > cat confdefs.h >>conftest.$ac_ext
11172 > cat >>conftest.$ac_ext <<_ACEOF
11173 > /* end confdefs.h.  */
11174 > #include <$ac_header>
11175 > _ACEOF
11176 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11177 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11178 >  ac_status=$?
11179 >  grep -v '^ *+' conftest.er1 >conftest.err
11180 >  rm -f conftest.er1
11181 >  cat conftest.err >&5
11182 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11183 >  (exit $ac_status); } >/dev/null; then
11184 >  if test -s conftest.err; then
11185 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11186 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11187 >  else
11188 >    ac_cpp_err=
11189 >  fi
11190 > else
11191 >  ac_cpp_err=yes
11192 > fi
11193 > if test -z "$ac_cpp_err"; then
11194 >  ac_header_preproc=yes
11195 > else
11196 >  echo "$as_me: failed program was:" >&5
11197 > sed 's/^/| /' conftest.$ac_ext >&5
11198 >
11199 >  ac_header_preproc=no
11200 > fi
11201 > rm -f conftest.err conftest.$ac_ext
11202 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11203 > echo "${ECHO_T}$ac_header_preproc" >&6
11204 >
11205 > # So?  What about this header?
11206 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11207 >  yes:no: )
11208 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11209 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11210 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11211 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11212 >    ac_header_preproc=yes
11213 >    ;;
11214 >  no:yes:* )
11215 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11216 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11217 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11218 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11219 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11220 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11221 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11222 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11223 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11224 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11225 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11226 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11227 >    (
11228 >      cat <<\_ASBOX
11229 > ## ------------------------------ ##
11230 > ## Report this to gezelter@nd.edu ##
11231 > ## ------------------------------ ##
11232 > _ASBOX
11233 >    ) |
11234 >      sed "s/^/$as_me: WARNING:     /" >&2
11235 >    ;;
11236 > esac
11237 > echo "$as_me:$LINENO: checking for $ac_header" >&5
11238 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11239 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11240 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11241   else
11242 <  echo "$as_me: failed program was:" >&5
4705 < sed 's/^/| /' conftest.$ac_ext >&5
4706 <
4707 < eval "$as_ac_Header=no"
11242 >  eval "$as_ac_Header=\$ac_header_preproc"
11243   fi
4709 rm -f conftest.$ac_objext conftest.$ac_ext
4710 fi
11244   echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11245   echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11246 +
11247 + fi
11248   if test `eval echo '${'$as_ac_Header'}'` = yes; then
11249    cat >>confdefs.h <<_ACEOF
11250   #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
# Line 4720 | Line 11255 | done
11255   done
11256  
11257  
11258 + fi
11259  
11260  
11261  
11262  
11263 <
4728 <
4729 <
4730 <
4731 <
4732 < for ac_header in unistd.h sys/pstat.h sys/sysmp.h sys/sysinfo.h sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h machine/hal_sysinfo.h
11263 > for ac_header in cmath
11264   do
11265   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11266   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 4745 | Line 11276 | cat >conftest.$ac_ext <<_ACEOF
11276   echo "$as_me:$LINENO: checking $ac_header usability" >&5
11277   echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11278   cat >conftest.$ac_ext <<_ACEOF
4748 #line $LINENO "configure"
11279   /* confdefs.h.  */
11280   _ACEOF
11281   cat confdefs.h >>conftest.$ac_ext
# Line 4756 | Line 11286 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11286   _ACEOF
11287   rm -f conftest.$ac_objext
11288   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11289 <  (eval $ac_compile) 2>&5
11289 >  (eval $ac_compile) 2>conftest.er1
11290    ac_status=$?
11291 +  grep -v '^ *+' conftest.er1 >conftest.err
11292 +  rm -f conftest.er1
11293 +  cat conftest.err >&5
11294    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11295    (exit $ac_status); } &&
11296 <         { ac_try='test -s conftest.$ac_objext'
11296 >         { ac_try='test -z "$ac_cxx_werror_flag"
11297 >                         || test ! -s conftest.err'
11298    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11299    (eval $ac_try) 2>&5
11300    ac_status=$?
11301    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11302 +  (exit $ac_status); }; } &&
11303 +         { ac_try='test -s conftest.$ac_objext'
11304 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11305 +  (eval $ac_try) 2>&5
11306 +  ac_status=$?
11307 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11308    (exit $ac_status); }; }; then
11309    ac_header_compiler=yes
11310   else
# Line 4773 | Line 11313 | fi
11313  
11314   ac_header_compiler=no
11315   fi
11316 < rm -f conftest.$ac_objext conftest.$ac_ext
11316 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11317   echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11318   echo "${ECHO_T}$ac_header_compiler" >&6
11319  
# Line 4781 | Line 11321 | cat >conftest.$ac_ext <<_ACEOF
11321   echo "$as_me:$LINENO: checking $ac_header presence" >&5
11322   echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11323   cat >conftest.$ac_ext <<_ACEOF
4784 #line $LINENO "configure"
11324   /* confdefs.h.  */
11325   _ACEOF
11326   cat confdefs.h >>conftest.$ac_ext
# Line 4798 | Line 11337 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11337    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11338    (exit $ac_status); } >/dev/null; then
11339    if test -s conftest.err; then
11340 <    ac_cpp_err=$ac_c_preproc_warn_flag
11340 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11341 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11342    else
11343      ac_cpp_err=
11344    fi
# Line 4818 | Line 11358 | echo "${ECHO_T}$ac_header_preproc" >&6
11358   echo "${ECHO_T}$ac_header_preproc" >&6
11359  
11360   # So?  What about this header?
11361 < case $ac_header_compiler:$ac_header_preproc in
11362 <  yes:no )
11361 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11362 >  yes:no: )
11363      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11364   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11365 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11366 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11367 <    (
4828 <      cat <<\_ASBOX
4829 < ## ------------------------------------ ##
4830 < ## Report this to bug-autoconf@gnu.org. ##
4831 < ## ------------------------------------ ##
4832 < _ASBOX
4833 <    ) |
4834 <      sed "s/^/$as_me: WARNING:     /" >&2
11365 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11366 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11367 >    ac_header_preproc=yes
11368      ;;
11369 <  no:yes )
11369 >  no:yes:* )
11370      { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11371   echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11372 <    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
11373 < echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
11372 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11373 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11374 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11375 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11376 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11377 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11378      { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11379   echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11380 +    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11381 + echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11382      (
11383        cat <<\_ASBOX
11384 < ## ------------------------------------ ##
11385 < ## Report this to bug-autoconf@gnu.org. ##
11386 < ## ------------------------------------ ##
11384 > ## ------------------------------ ##
11385 > ## Report this to gezelter@nd.edu ##
11386 > ## ------------------------------ ##
11387   _ASBOX
11388      ) |
11389        sed "s/^/$as_me: WARNING:     /" >&2
# Line 4855 | Line 11394 | else
11394   if eval "test \"\${$as_ac_Header+set}\" = set"; then
11395    echo $ECHO_N "(cached) $ECHO_C" >&6
11396   else
11397 <  eval "$as_ac_Header=$ac_header_preproc"
11397 >  eval "$as_ac_Header=\$ac_header_preproc"
11398   fi
11399   echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11400   echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
# Line 4873 | Line 11412 | done
11412  
11413  
11414  
11415 <
11416 <
11417 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
4879 < do
4880 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
4881 < echo "$as_me:$LINENO: checking for $ac_func" >&5
4882 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
4883 < if eval "test \"\${$as_ac_var+set}\" = set"; then
11415 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11416 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11417 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11418    echo $ECHO_N "(cached) $ECHO_C" >&6
11419   else
11420 <  cat >conftest.$ac_ext <<_ACEOF
11421 < #line $LINENO "configure"
11420 >
11421 >      ac_cv_cxx_have_std_iostream=no
11422 >      ac_cv_cxx_need_use_std_iostream=no
11423 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11424 >
11425 >
11426 >        ac_ext=cc
11427 > ac_cpp='$CXXCPP $CPPFLAGS'
11428 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11429 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11430 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11431 >
11432 >        cat >conftest.$ac_ext <<_ACEOF
11433   /* confdefs.h.  */
11434   _ACEOF
11435   cat confdefs.h >>conftest.$ac_ext
11436   cat >>conftest.$ac_ext <<_ACEOF
11437   /* end confdefs.h.  */
11438 < /* System header to define __stub macros and hopefully few prototypes,
11439 <    which can conflict with char $ac_func (); below.
11440 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4896 <    <limits.h> exists even on freestanding compilers.  */
4897 < #ifdef __STDC__
4898 < # include <limits.h>
11438 >
11439 > #ifdef HAVE_IOSTREAM
11440 > #include <iostream>
11441   #else
11442 < # include <assert.h>
4901 < #endif
4902 < /* Override any gcc2 internal prototype to avoid an error.  */
4903 < #ifdef __cplusplus
4904 < extern "C"
4905 < {
11442 > #include <iostream.h>
11443   #endif
11444 < /* We use char because int might match the return type of a gcc2
11445 <   builtin and then its argument prototype would still apply.  */
11446 < char $ac_func ();
11447 < /* The GNU C library defines this for functions which it implements
11448 <    to always fail with ENOSYS.  Some functions are actually named
11449 <    something starting with __ and the normal name is an alias.  */
11450 < #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4914 < choke me
4915 < #else
4916 < char (*f) () = $ac_func;
11444 >
11445 > #ifdef FC_DUMMY_MAIN
11446 > #ifndef FC_DUMMY_MAIN_EQ_F77
11447 > #  ifdef __cplusplus
11448 >     extern "C"
11449 > #  endif
11450 >   int FC_DUMMY_MAIN() { return 1; }
11451   #endif
4918 #ifdef __cplusplus
4919 }
11452   #endif
4921
11453   int
11454   main ()
11455   {
11456 < return f != $ac_func;
11456 > std::cout<<"Hello World"<<std::endl;return 0;
11457    ;
11458    return 0;
11459   }
11460   _ACEOF
11461 < rm -f conftest.$ac_objext conftest$ac_exeext
11462 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11463 <  (eval $ac_link) 2>&5
11461 > rm -f conftest.$ac_objext
11462 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11463 >  (eval $ac_compile) 2>conftest.er1
11464    ac_status=$?
11465 +  grep -v '^ *+' conftest.er1 >conftest.err
11466 +  rm -f conftest.er1
11467 +  cat conftest.err >&5
11468    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11469    (exit $ac_status); } &&
11470 <         { ac_try='test -s conftest$ac_exeext'
11470 >         { ac_try='test -z "$ac_cxx_werror_flag"
11471 >                         || test ! -s conftest.err'
11472    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11473    (eval $ac_try) 2>&5
11474    ac_status=$?
11475    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11476 +  (exit $ac_status); }; } &&
11477 +         { ac_try='test -s conftest.$ac_objext'
11478 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11479 +  (eval $ac_try) 2>&5
11480 +  ac_status=$?
11481 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11482    (exit $ac_status); }; }; then
11483 <  eval "$as_ac_var=yes"
11483 >  ac_cv_cxx_have_std_iostream=yes
11484   else
11485    echo "$as_me: failed program was:" >&5
11486   sed 's/^/| /' conftest.$ac_ext >&5
11487  
4947 eval "$as_ac_var=no"
11488   fi
11489 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
11490 < fi
4951 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
4952 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
4953 < if test `eval echo '${'$as_ac_var'}'` = yes; then
4954 <  cat >>confdefs.h <<_ACEOF
4955 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
4956 < _ACEOF
4957 <
4958 < fi
4959 < done
4960 <
4961 < # special check for _system_configuration because AIX <4.3.2 do not
4962 < # contain the `physmem' member.
4963 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
4964 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
4965 < cat >conftest.$ac_ext <<_ACEOF
4966 < #line $LINENO "configure"
11489 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11490 >        cat >conftest.$ac_ext <<_ACEOF
11491   /* confdefs.h.  */
11492   _ACEOF
11493   cat confdefs.h >>conftest.$ac_ext
11494   cat >>conftest.$ac_ext <<_ACEOF
11495   /* end confdefs.h.  */
11496 < #include <sys/systemcfg.h>
11496 >
11497 > #define __USE_STD_IOSTREAM 1
11498 > #ifdef HAVE_IOSTREAM
11499 > #include <iostream>
11500 > #else
11501 > #include <iostream.h>
11502 > #endif
11503 >
11504 > #ifdef FC_DUMMY_MAIN
11505 > #ifndef FC_DUMMY_MAIN_EQ_F77
11506 > #  ifdef __cplusplus
11507 >     extern "C"
11508 > #  endif
11509 >   int FC_DUMMY_MAIN() { return 1; }
11510 > #endif
11511 > #endif
11512   int
11513   main ()
11514   {
11515 < double x = _system_configuration.physmem;
11515 > std::cout<<"Hello World"<<std::endl;return 0;
11516    ;
11517    return 0;
11518   }
11519   _ACEOF
11520   rm -f conftest.$ac_objext
11521   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11522 <  (eval $ac_compile) 2>&5
11522 >  (eval $ac_compile) 2>conftest.er1
11523    ac_status=$?
11524 +  grep -v '^ *+' conftest.er1 >conftest.err
11525 +  rm -f conftest.er1
11526 +  cat conftest.err >&5
11527    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11528    (exit $ac_status); } &&
11529 <         { ac_try='test -s conftest.$ac_objext'
11529 >         { ac_try='test -z "$ac_cxx_werror_flag"
11530 >                         || test ! -s conftest.err'
11531    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11532    (eval $ac_try) 2>&5
11533    ac_status=$?
11534    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11535 +  (exit $ac_status); }; } &&
11536 +         { ac_try='test -s conftest.$ac_objext'
11537 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11538 +  (eval $ac_try) 2>&5
11539 +  ac_status=$?
11540 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11541    (exit $ac_status); }; }; then
11542 <  echo "$as_me:$LINENO: result: yes" >&5
11543 < echo "${ECHO_T}yes" >&6
11542 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11543 > else
11544 >  echo "$as_me: failed program was:" >&5
11545 > sed 's/^/| /' conftest.$ac_ext >&5
11546  
11547 + fi
11548 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11549 +        ac_ext=cc
11550 + ac_cpp='$CXXCPP $CPPFLAGS'
11551 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11552 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11553 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11554 +
11555 +      fi
11556 +
11557 + fi
11558 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11559 + echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11560 +  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11561 +
11562   cat >>confdefs.h <<\_ACEOF
11563 < #define HAVE__SYSTEM_CONFIGURATION 1
11563 > #define HAVE_STD_IOSTREAM 1
11564   _ACEOF
11565  
11566 +  fi
11567 +  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11568 +
11569 + cat >>confdefs.h <<\_ACEOF
11570 + #define __USE_STD_IOSTREAM 1
11571 + _ACEOF
11572 +
11573 +  fi
11574 +
11575 +
11576 +
11577 +
11578 +  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11579 + echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11580 + if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11581 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11582   else
11583 +
11584 +      ac_cv_cxx_have_std_stl=no
11585 +      if test "x$ac_cv_cxx_namespaces" = xyes; then
11586 +
11587 +
11588 +        ac_ext=cc
11589 + ac_cpp='$CXXCPP $CPPFLAGS'
11590 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11591 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11592 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11593 +
11594 +        cat >conftest.$ac_ext <<_ACEOF
11595 + /* confdefs.h.  */
11596 + _ACEOF
11597 + cat confdefs.h >>conftest.$ac_ext
11598 + cat >>conftest.$ac_ext <<_ACEOF
11599 + /* end confdefs.h.  */
11600 + #include <list>
11601 +
11602 + #ifdef FC_DUMMY_MAIN
11603 + #ifndef FC_DUMMY_MAIN_EQ_F77
11604 + #  ifdef __cplusplus
11605 +     extern "C"
11606 + #  endif
11607 +   int FC_DUMMY_MAIN() { return 1; }
11608 + #endif
11609 + #endif
11610 + int
11611 + main ()
11612 + {
11613 + std::list<int> foo;return 0;
11614 +  ;
11615 +  return 0;
11616 + }
11617 + _ACEOF
11618 + rm -f conftest.$ac_objext
11619 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11620 +  (eval $ac_compile) 2>conftest.er1
11621 +  ac_status=$?
11622 +  grep -v '^ *+' conftest.er1 >conftest.err
11623 +  rm -f conftest.er1
11624 +  cat conftest.err >&5
11625 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11626 +  (exit $ac_status); } &&
11627 +         { ac_try='test -z "$ac_cxx_werror_flag"
11628 +                         || test ! -s conftest.err'
11629 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11630 +  (eval $ac_try) 2>&5
11631 +  ac_status=$?
11632 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11633 +  (exit $ac_status); }; } &&
11634 +         { ac_try='test -s conftest.$ac_objext'
11635 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11636 +  (eval $ac_try) 2>&5
11637 +  ac_status=$?
11638 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11639 +  (exit $ac_status); }; }; then
11640 +  ac_cv_cxx_have_std_stl=yes
11641 + else
11642    echo "$as_me: failed program was:" >&5
11643   sed 's/^/| /' conftest.$ac_ext >&5
11644  
5004 echo "$as_me:$LINENO: result: no" >&5
5005 echo "${ECHO_T}no" >&6
11645   fi
11646 < rm -f conftest.$ac_objext conftest.$ac_ext
11646 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11647 >        ac_ext=cc
11648 > ac_cpp='$CXXCPP $CPPFLAGS'
11649 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11650 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11651 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11652  
11653 <  # clean out junk possibly left behind by a previous configuration
5010 <  rm -f src/getopt.h
5011 <  # Check for getopt_long support
11653 >      fi
11654  
11655 < for ac_header in getopt.h
11655 > fi
11656 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11657 > echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11658 >  if test "$ac_cv_cxx_have_std_stl" = yes; then
11659 >
11660 > cat >>confdefs.h <<\_ACEOF
11661 > #define HAVE_STD_STL 1
11662 > _ACEOF
11663 >
11664 >  fi
11665 >
11666 >
11667 >
11668 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11669 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11670 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11671 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11672 > else
11673 >
11674 >    ac_cv_cxx_have_fstream_attach=no
11675 >
11676 >
11677 >    ac_ext=cc
11678 > ac_cpp='$CXXCPP $CPPFLAGS'
11679 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11680 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11681 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11682 >
11683 >    cat >conftest.$ac_ext <<_ACEOF
11684 > /* confdefs.h.  */
11685 > _ACEOF
11686 > cat confdefs.h >>conftest.$ac_ext
11687 > cat >>conftest.$ac_ext <<_ACEOF
11688 > /* end confdefs.h.  */
11689 >
11690 > #ifdef HAVE_IOSTREAM
11691 > #include <fstream>
11692 > #else
11693 > #include <fstream.h>
11694 > #endif
11695 > #ifdef HAVE_STD_IOSTREAM
11696 > using namespace std;
11697 > #endif
11698 >
11699 > #ifdef FC_DUMMY_MAIN
11700 > #ifndef FC_DUMMY_MAIN_EQ_F77
11701 > #  ifdef __cplusplus
11702 >     extern "C"
11703 > #  endif
11704 >   int FC_DUMMY_MAIN() { return 1; }
11705 > #endif
11706 > #endif
11707 > int
11708 > main ()
11709 > {
11710 > int fd=0;ofstream s;s.attach(fd);
11711 >  ;
11712 >  return 0;
11713 > }
11714 > _ACEOF
11715 > rm -f conftest.$ac_objext
11716 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11717 >  (eval $ac_compile) 2>conftest.er1
11718 >  ac_status=$?
11719 >  grep -v '^ *+' conftest.er1 >conftest.err
11720 >  rm -f conftest.er1
11721 >  cat conftest.err >&5
11722 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11723 >  (exit $ac_status); } &&
11724 >         { ac_try='test -z "$ac_cxx_werror_flag"
11725 >                         || test ! -s conftest.err'
11726 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11727 >  (eval $ac_try) 2>&5
11728 >  ac_status=$?
11729 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11730 >  (exit $ac_status); }; } &&
11731 >         { ac_try='test -s conftest.$ac_objext'
11732 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11733 >  (eval $ac_try) 2>&5
11734 >  ac_status=$?
11735 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11736 >  (exit $ac_status); }; }; then
11737 >  ac_cv_cxx_have_fstream_attach=yes
11738 > else
11739 >  echo "$as_me: failed program was:" >&5
11740 > sed 's/^/| /' conftest.$ac_ext >&5
11741 >
11742 > fi
11743 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11744 >    ac_ext=cc
11745 > ac_cpp='$CXXCPP $CPPFLAGS'
11746 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11747 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11748 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11749 >
11750 >
11751 > fi
11752 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11753 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11754 >  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11755 >
11756 > cat >>confdefs.h <<\_ACEOF
11757 > #define HAVE_FSTREAM_ATTACH 1
11758 > _ACEOF
11759 >
11760 >  fi
11761 >
11762 >
11763 >
11764 >  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11765 > echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11766 > if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11767 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11768 > else
11769 >
11770 >    ac_cv_cxx_have_fstream_open=no
11771 >    ac_cv_cxx_fstream_open_prot=no
11772 >
11773 >
11774 >    ac_ext=cc
11775 > ac_cpp='$CXXCPP $CPPFLAGS'
11776 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11777 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11778 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11779 >
11780 >    # Try with 2 parameters
11781 >    cat >conftest.$ac_ext <<_ACEOF
11782 > /* confdefs.h.  */
11783 > _ACEOF
11784 > cat confdefs.h >>conftest.$ac_ext
11785 > cat >>conftest.$ac_ext <<_ACEOF
11786 > /* end confdefs.h.  */
11787 >
11788 > #ifdef HAVE_IOSTREAM
11789 > #include <fstream>
11790 > #else
11791 > #include <fstream.h>
11792 > #endif
11793 > #ifdef HAVE_STD_IOSTREAM
11794 > using namespace std;
11795 > #endif
11796 >
11797 > #ifdef FC_DUMMY_MAIN
11798 > #ifndef FC_DUMMY_MAIN_EQ_F77
11799 > #  ifdef __cplusplus
11800 >     extern "C"
11801 > #  endif
11802 >   int FC_DUMMY_MAIN() { return 1; }
11803 > #endif
11804 > #endif
11805 > int
11806 > main ()
11807 > {
11808 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11809 >  ;
11810 >  return 0;
11811 > }
11812 > _ACEOF
11813 > rm -f conftest.$ac_objext
11814 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11815 >  (eval $ac_compile) 2>conftest.er1
11816 >  ac_status=$?
11817 >  grep -v '^ *+' conftest.er1 >conftest.err
11818 >  rm -f conftest.er1
11819 >  cat conftest.err >&5
11820 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11821 >  (exit $ac_status); } &&
11822 >         { ac_try='test -z "$ac_cxx_werror_flag"
11823 >                         || test ! -s conftest.err'
11824 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11825 >  (eval $ac_try) 2>&5
11826 >  ac_status=$?
11827 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11828 >  (exit $ac_status); }; } &&
11829 >         { ac_try='test -s conftest.$ac_objext'
11830 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11831 >  (eval $ac_try) 2>&5
11832 >  ac_status=$?
11833 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11834 >  (exit $ac_status); }; }; then
11835 >  ac_cv_cxx_have_fstream_open=yes
11836 > else
11837 >  echo "$as_me: failed program was:" >&5
11838 > sed 's/^/| /' conftest.$ac_ext >&5
11839 >
11840 > fi
11841 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11842 >    # Try with mode parameter
11843 >    cat >conftest.$ac_ext <<_ACEOF
11844 > /* confdefs.h.  */
11845 > _ACEOF
11846 > cat confdefs.h >>conftest.$ac_ext
11847 > cat >>conftest.$ac_ext <<_ACEOF
11848 > /* end confdefs.h.  */
11849 >
11850 > #ifdef HAVE_IOSTREAM
11851 > #include <fstream>
11852 > #else
11853 > #include <fstream.h>
11854 > #endif
11855 > #ifdef HAVE_STD_IOSTREAM
11856 > using namespace std;
11857 > #endif
11858 >
11859 > #ifdef FC_DUMMY_MAIN
11860 > #ifndef FC_DUMMY_MAIN_EQ_F77
11861 > #  ifdef __cplusplus
11862 >     extern "C"
11863 > #  endif
11864 >   int FC_DUMMY_MAIN() { return 1; }
11865 > #endif
11866 > #endif
11867 > int
11868 > main ()
11869 > {
11870 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11871 >  ;
11872 >  return 0;
11873 > }
11874 > _ACEOF
11875 > rm -f conftest.$ac_objext
11876 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11877 >  (eval $ac_compile) 2>conftest.er1
11878 >  ac_status=$?
11879 >  grep -v '^ *+' conftest.er1 >conftest.err
11880 >  rm -f conftest.er1
11881 >  cat conftest.err >&5
11882 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11883 >  (exit $ac_status); } &&
11884 >         { ac_try='test -z "$ac_cxx_werror_flag"
11885 >                         || test ! -s conftest.err'
11886 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11887 >  (eval $ac_try) 2>&5
11888 >  ac_status=$?
11889 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11890 >  (exit $ac_status); }; } &&
11891 >         { ac_try='test -s conftest.$ac_objext'
11892 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11893 >  (eval $ac_try) 2>&5
11894 >  ac_status=$?
11895 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11896 >  (exit $ac_status); }; }; then
11897 >  ac_cv_cxx_fstream_open_prot=yes
11898 > else
11899 >  echo "$as_me: failed program was:" >&5
11900 > sed 's/^/| /' conftest.$ac_ext >&5
11901 >
11902 > fi
11903 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11904 >    ac_ext=cc
11905 > ac_cpp='$CXXCPP $CPPFLAGS'
11906 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11907 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11908 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11909 >
11910 >
11911 > fi
11912 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11913 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11914 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11915 >
11916 > cat >>confdefs.h <<\_ACEOF
11917 > #define HAVE_FSTREAM_OPEN 1
11918 > _ACEOF
11919 >
11920 >  fi
11921 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11922 >
11923 > cat >>confdefs.h <<\_ACEOF
11924 > #define FSTREAM_OPEN_PROT 1
11925 > _ACEOF
11926 >
11927 >  fi
11928 >
11929 >
11930 >
11931 >
11932 >
11933 >
11934 >
11935 > for ac_header in ctype.h iostream fstream sstream strstream
11936   do
11937   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11938   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 5026 | Line 11948 | cat >conftest.$ac_ext <<_ACEOF
11948   echo "$as_me:$LINENO: checking $ac_header usability" >&5
11949   echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11950   cat >conftest.$ac_ext <<_ACEOF
5029 #line $LINENO "configure"
11951   /* confdefs.h.  */
11952   _ACEOF
11953   cat confdefs.h >>conftest.$ac_ext
# Line 5037 | Line 11958 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11958   _ACEOF
11959   rm -f conftest.$ac_objext
11960   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11961 <  (eval $ac_compile) 2>&5
11961 >  (eval $ac_compile) 2>conftest.er1
11962    ac_status=$?
11963 +  grep -v '^ *+' conftest.er1 >conftest.err
11964 +  rm -f conftest.er1
11965 +  cat conftest.err >&5
11966    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11967    (exit $ac_status); } &&
11968 <         { ac_try='test -s conftest.$ac_objext'
11968 >         { ac_try='test -z "$ac_cxx_werror_flag"
11969 >                         || test ! -s conftest.err'
11970    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11971    (eval $ac_try) 2>&5
11972    ac_status=$?
11973    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11974 +  (exit $ac_status); }; } &&
11975 +         { ac_try='test -s conftest.$ac_objext'
11976 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11977 +  (eval $ac_try) 2>&5
11978 +  ac_status=$?
11979 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11980    (exit $ac_status); }; }; then
11981    ac_header_compiler=yes
11982   else
# Line 5054 | Line 11985 | fi
11985  
11986   ac_header_compiler=no
11987   fi
11988 < rm -f conftest.$ac_objext conftest.$ac_ext
11988 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11989   echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11990   echo "${ECHO_T}$ac_header_compiler" >&6
11991  
# Line 5062 | Line 11993 | cat >conftest.$ac_ext <<_ACEOF
11993   echo "$as_me:$LINENO: checking $ac_header presence" >&5
11994   echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11995   cat >conftest.$ac_ext <<_ACEOF
5065 #line $LINENO "configure"
11996   /* confdefs.h.  */
11997   _ACEOF
11998   cat confdefs.h >>conftest.$ac_ext
# Line 5079 | Line 12009 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
12009    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12010    (exit $ac_status); } >/dev/null; then
12011    if test -s conftest.err; then
12012 <    ac_cpp_err=$ac_c_preproc_warn_flag
12012 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
12013 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
12014    else
12015      ac_cpp_err=
12016    fi
# Line 5099 | Line 12030 | echo "${ECHO_T}$ac_header_preproc" >&6
12030   echo "${ECHO_T}$ac_header_preproc" >&6
12031  
12032   # So?  What about this header?
12033 < case $ac_header_compiler:$ac_header_preproc in
12034 <  yes:no )
12033 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
12034 >  yes:no: )
12035      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
12036   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
12037 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
12038 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
12039 <    (
5109 <      cat <<\_ASBOX
5110 < ## ------------------------------------ ##
5111 < ## Report this to bug-autoconf@gnu.org. ##
5112 < ## ------------------------------------ ##
5113 < _ASBOX
5114 <    ) |
5115 <      sed "s/^/$as_me: WARNING:     /" >&2
12037 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
12038 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
12039 >    ac_header_preproc=yes
12040      ;;
12041 <  no:yes )
12041 >  no:yes:* )
12042      { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
12043   echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
12044 <    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
12045 < echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
12044 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
12045 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
12046 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
12047 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
12048 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
12049 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
12050      { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
12051   echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
12052 +    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
12053 + echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
12054      (
12055        cat <<\_ASBOX
12056 < ## ------------------------------------ ##
12057 < ## Report this to bug-autoconf@gnu.org. ##
12058 < ## ------------------------------------ ##
12056 > ## ------------------------------ ##
12057 > ## Report this to gezelter@nd.edu ##
12058 > ## ------------------------------ ##
12059   _ASBOX
12060      ) |
12061        sed "s/^/$as_me: WARNING:     /" >&2
# Line 5136 | Line 12066 | else
12066   if eval "test \"\${$as_ac_Header+set}\" = set"; then
12067    echo $ECHO_N "(cached) $ECHO_C" >&6
12068   else
12069 <  eval "$as_ac_Header=$ac_header_preproc"
12069 >  eval "$as_ac_Header=\$ac_header_preproc"
12070   fi
12071   echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
12072   echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
# Line 5151 | Line 12081 | done
12081  
12082   done
12083  
12084 + # AC_CPP_FUNC
12085 + # ------------------ #
12086 + # Checks to see if ANSI C99 CPP variable __func__ works.
12087 + # If not, perhaps __FUNCTION__ works instead.
12088 + # If not, we'll just define __func__ to "".
12089 + # AC_CPP_FUNC
12090  
12091 < for ac_func in getopt_long
12092 < do
12093 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
12094 < echo "$as_me:$LINENO: checking for $ac_func" >&5
5159 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5160 < if eval "test \"\${$as_ac_var+set}\" = set"; then
12091 >
12092 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
12093 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
12094 > if test "${ac_cv_cpp_func+set}" = set; then
12095    echo $ECHO_N "(cached) $ECHO_C" >&6
12096   else
12097    cat >conftest.$ac_ext <<_ACEOF
5164 #line $LINENO "configure"
12098   /* confdefs.h.  */
12099   _ACEOF
12100   cat confdefs.h >>conftest.$ac_ext
12101   cat >>conftest.$ac_ext <<_ACEOF
12102   /* end confdefs.h.  */
12103 < /* System header to define __stub macros and hopefully few prototypes,
12104 <    which can conflict with char $ac_func (); below.
12105 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
12106 <    <limits.h> exists even on freestanding compilers.  */
12107 < #ifdef __STDC__
12108 < # include <limits.h>
12109 < #else
5177 < # include <assert.h>
12103 >
12104 > #ifdef FC_DUMMY_MAIN
12105 > #ifndef FC_DUMMY_MAIN_EQ_F77
12106 > #  ifdef __cplusplus
12107 >     extern "C"
12108 > #  endif
12109 >   int FC_DUMMY_MAIN() { return 1; }
12110   #endif
5179 /* Override any gcc2 internal prototype to avoid an error.  */
5180 #ifdef __cplusplus
5181 extern "C"
5182 {
12111   #endif
5184 /* We use char because int might match the return type of a gcc2
5185   builtin and then its argument prototype would still apply.  */
5186 char $ac_func ();
5187 /* The GNU C library defines this for functions which it implements
5188    to always fail with ENOSYS.  Some functions are actually named
5189    something starting with __ and the normal name is an alias.  */
5190 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
5191 choke me
5192 #else
5193 char (*f) () = $ac_func;
5194 #endif
5195 #ifdef __cplusplus
5196 }
5197 #endif
5198
12112   int
12113   main ()
12114   {
12115 < return f != $ac_func;
12115 > const char *foo = __func__;
12116    ;
12117    return 0;
12118   }
12119   _ACEOF
12120 < rm -f conftest.$ac_objext conftest$ac_exeext
12121 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12122 <  (eval $ac_link) 2>&5
12120 > rm -f conftest.$ac_objext
12121 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12122 >  (eval $ac_compile) 2>conftest.er1
12123    ac_status=$?
12124 +  grep -v '^ *+' conftest.er1 >conftest.err
12125 +  rm -f conftest.er1
12126 +  cat conftest.err >&5
12127    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12128    (exit $ac_status); } &&
12129 <         { ac_try='test -s conftest$ac_exeext'
12129 >         { ac_try='test -z "$ac_cxx_werror_flag"
12130 >                         || test ! -s conftest.err'
12131    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12132    (eval $ac_try) 2>&5
12133    ac_status=$?
12134    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12135 +  (exit $ac_status); }; } &&
12136 +         { ac_try='test -s conftest.$ac_objext'
12137 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12138 +  (eval $ac_try) 2>&5
12139 +  ac_status=$?
12140 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12141    (exit $ac_status); }; }; then
12142 <  eval "$as_ac_var=yes"
12142 >  ac_cv_cpp_func=yes
12143   else
12144    echo "$as_me: failed program was:" >&5
12145   sed 's/^/| /' conftest.$ac_ext >&5
12146  
5224 eval "$as_ac_var=no"
5225 fi
5226 rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
5227 fi
5228 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
5229 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
5230 if test `eval echo '${'$as_ac_var'}'` = yes; then
5231  cat >>confdefs.h <<_ACEOF
5232 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
5233 _ACEOF
5234
5235 else
5236  # FreeBSD has a gnugetopt library for this
5237    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
5238 echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
5239 if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
5240  echo $ECHO_N "(cached) $ECHO_C" >&6
5241 else
5242  ac_check_lib_save_LIBS=$LIBS
5243 LIBS="-lgnugetopt  $LIBS"
12147   cat >conftest.$ac_ext <<_ACEOF
5245 #line $LINENO "configure"
12148   /* confdefs.h.  */
12149   _ACEOF
12150   cat confdefs.h >>conftest.$ac_ext
12151   cat >>conftest.$ac_ext <<_ACEOF
12152   /* end confdefs.h.  */
12153  
12154 < /* Override any gcc2 internal prototype to avoid an error.  */
12155 < #ifdef __cplusplus
12156 < extern "C"
12154 > #ifdef FC_DUMMY_MAIN
12155 > #ifndef FC_DUMMY_MAIN_EQ_F77
12156 > #  ifdef __cplusplus
12157 >     extern "C"
12158 > #  endif
12159 >   int FC_DUMMY_MAIN() { return 1; }
12160   #endif
12161 < /* We use char because int might match the return type of a gcc2
5257 <   builtin and then its argument prototype would still apply.  */
5258 < char getopt_long ();
12161 > #endif
12162   int
12163   main ()
12164   {
12165 < getopt_long ();
12165 > const char *foo = __FUNCTION__;
12166    ;
12167    return 0;
12168   }
12169   _ACEOF
12170 < rm -f conftest.$ac_objext conftest$ac_exeext
12171 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12172 <  (eval $ac_link) 2>&5
12170 > rm -f conftest.$ac_objext
12171 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12172 >  (eval $ac_compile) 2>conftest.er1
12173    ac_status=$?
12174 +  grep -v '^ *+' conftest.er1 >conftest.err
12175 +  rm -f conftest.er1
12176 +  cat conftest.err >&5
12177    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12178    (exit $ac_status); } &&
12179 <         { ac_try='test -s conftest$ac_exeext'
12179 >         { ac_try='test -z "$ac_cxx_werror_flag"
12180 >                         || test ! -s conftest.err'
12181    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12182    (eval $ac_try) 2>&5
12183    ac_status=$?
12184    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12185 +  (exit $ac_status); }; } &&
12186 +         { ac_try='test -s conftest.$ac_objext'
12187 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12188 +  (eval $ac_try) 2>&5
12189 +  ac_status=$?
12190 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12191    (exit $ac_status); }; }; then
12192 <  ac_cv_lib_gnugetopt_getopt_long=yes
12192 >  ac_cv_cpp_func=__FUNCTION__
12193   else
12194    echo "$as_me: failed program was:" >&5
12195   sed 's/^/| /' conftest.$ac_ext >&5
12196  
12197 < ac_cv_lib_gnugetopt_getopt_long=no
12197 > ac_cv_cpp_func=no
12198   fi
12199 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
5287 < LIBS=$ac_check_lib_save_LIBS
12199 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12200   fi
12201 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
12202 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
12203 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
12204 <  cat >>confdefs.h <<\_ACEOF
12205 < #define HAVE_GETOPT_LONG 1
12201 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12202 > fi
12203 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
12204 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
12205 > if test $ac_cv_cpp_func = __FUNCTION__; then
12206 >
12207 > cat >>confdefs.h <<\_ACEOF
12208 > #define __func__ __FUNCTION__
12209   _ACEOF
12210  
12211 < else
5297 <  # use the GNU replacement
5298 <      LIBOBJS="$LIBOBJS getopt.$ac_objext"
5299 <      LIBOBJS="$LIBOBJS getopt1.$ac_objext"
5300 <                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
12211 > elif test $ac_cv_cpp_func = no; then
12212  
12213 < fi
12213 > cat >>confdefs.h <<\_ACEOF
12214 > #define __func__ ""
12215 > _ACEOF
12216  
12217   fi
5305 done
12218  
12219  
12220  
12221 +
12222 +
12223   case $debug in
12224    1)
12225       ;;
# Line 5314 | Line 12228 | case $debug in
12228  
12229  
12230  
12231 + # Try to determine "good" native compiler flags if none specified on command
12232 + # line
12233  
12234 + if test "$ac_test_FFLAGS" != "set"; then
12235 +  FCFLAGS=""
12236 +  case "${host_cpu}-${host_os}" in
12237  
12238 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
12239 +                    FCFLAGS="-O3 -ip -no-prec-div -cxxlib-icc"
12240 +                fi;;
12241 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
12242 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12243 +                fi;;
12244 +   powerpc*-aix*)
12245 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12246 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
12247 +                echo "*******************************************************"
12248 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12249 +                echo "*  recommended that you use                           *"
12250 +                echo "*                                                     *"
12251 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12252 +                echo "*                                 ^^^                 *"
12253 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12254 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12255 +                echo "*******************************************************"
12256 +        fi;;
12257 +   *darwin*)
12258 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12259 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12260 +        fi
12261 +        if test "$FC" = ifort; then
12262 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
12263 +        fi;;
12264 +  esac
12265 +
12266 +  if test -n "$CPU_FLAGS"; then
12267 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
12268 +  fi
12269 +
12270 +  if test -z "$FCFLAGS"; then
12271 +        echo ""
12272 +        echo "*********************************************************"
12273 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12274 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12275 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
12276 +        echo "*********************************************************"
12277 +        echo ""
12278 +        FCFLAGS="-O3"
12279 +  fi
12280 +
12281 +
12282 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12283 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
12284 + if test "${ac_guessed_f90flags+set}" = set; then
12285 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12286 + else
12287 +
12288 +
12289 +
12290 + ac_ext=${FC_SRCEXT-f}
12291 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
12292 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
12293 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12294 +
12295 + echo 'program main' > conftest.$ac_ext
12296 + echo 'end program main' >> conftest.$ac_ext
12297 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12298 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12299 +  (eval $ac_compile) 2>&5
12300 +  ac_status=$?
12301 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12302 +  (exit $ac_status); }; then
12303 +        ac_guessed_f90flags=yes
12304 + else
12305 +        ac_guessed_f90flags=no
12306 + fi
12307 + rm -f conftest*
12308 + ac_ext=cc
12309 + ac_cpp='$CXXCPP $CPPFLAGS'
12310 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12311 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12312 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12313 +
12314 +
12315 + fi
12316 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12317 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
12318 + if test "$ac_guessed_f90flags" = yes; then
12319 +        :
12320 +
12321 + else
12322 +        :
12323 +
12324 +        echo ""
12325 +        echo "**********************************************************"
12326 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12327 +        echo "* your compiler.                                        *"
12328 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12329 +        echo "*********************************************************"
12330 +        echo ""
12331 +        FCFLAGS=""
12332 +
12333 + fi
12334 +
12335 +
12336 + fi
12337 +
12338 +
12339 +
12340 +
12341 +
12342 +
12343 +
12344   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12345   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12346   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 5324 | Line 12349 | cat > conftest.c <<EOF
12349  
12350   cat > conftest.c <<EOF
12351   #ifdef __GNUC__
12352 <  #ifndef __INTEL_COMPILER
12352 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12353 >     no;
12354 >  #else
12355       yes;
12356    #endif
12357   #endif
# Line 5362 | Line 12389 | if test "$ac_test_CFLAGS" != "set"; then
12389                      CFLAGS="-O"
12390                  fi;;
12391    sparc-solaris2*) if test "$CC" = cc; then
12392 <                    CFLAGS="-native -fast -xO5 -dalign"
12392 >                    CFLAGS="-O -dalign"
12393                   fi;;
12394  
12395    alpha*-osf*)  if test "$CC" = cc; then
# Line 5392 | Line 12419 | if test "$ac_test_CFLAGS" != "set"; then
12419     *darwin*)
12420          if test "$CC" = xlc -o "$CC" = cc; then
12421                  CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12422 +        fi
12423 +        if test "$CC" = icc; then
12424 +                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12425          fi;;
12426    esac
12427  
# Line 5405 | Line 12435 | if test "$ac_test_CFLAGS" != "set"; then
12435      # -malign-double for x86 systems
12436  
12437  
12438 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12439 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12438 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12439 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12440   if test "${ac_align_double+set}" = set; then
12441    echo $ECHO_N "(cached) $ECHO_C" >&6
12442   else
12443    echo 'void f(){}' > conftest.c
12444 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12444 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12445          ac_align_double=yes
12446   else
12447          ac_align_double=no
# Line 5432 | Line 12462 | fi
12462      # -fstrict-aliasing for gcc-2.95+
12463  
12464  
12465 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12466 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12465 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12466 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12467   if test "${ac_fstrict_aliasing+set}" = set; then
12468    echo $ECHO_N "(cached) $ECHO_C" >&6
12469   else
12470    echo 'void f(){}' > conftest.c
12471 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12471 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12472          ac_fstrict_aliasing=yes
12473   else
12474          ac_fstrict_aliasing=no
# Line 5463 | Line 12493 | fi
12493                    case "${host_cpu}" in
12494            i586*)
12495  
12496 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12497 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12496 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12497 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12498   if test "${ac_cpu_pentium+set}" = set; then
12499    echo $ECHO_N "(cached) $ECHO_C" >&6
12500   else
12501    echo 'void f(){}' > conftest.c
12502 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12502 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12503          ac_cpu_pentium=yes
12504   else
12505          ac_cpu_pentium=no
# Line 5486 | Line 12516 | else
12516          :
12517  
12518  
12519 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12520 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12519 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12520 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12521   if test "${ac_pentium+set}" = set; then
12522    echo $ECHO_N "(cached) $ECHO_C" >&6
12523   else
12524    echo 'void f(){}' > conftest.c
12525 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12525 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12526          ac_pentium=yes
12527   else
12528          ac_pentium=no
# Line 5515 | Line 12545 | fi
12545                    ;;
12546            i686*)
12547  
12548 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12549 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12548 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12549 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12550   if test "${ac_cpu_pentiumpro+set}" = set; then
12551    echo $ECHO_N "(cached) $ECHO_C" >&6
12552   else
12553    echo 'void f(){}' > conftest.c
12554 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12554 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12555          ac_cpu_pentiumpro=yes
12556   else
12557          ac_cpu_pentiumpro=no
# Line 5538 | Line 12568 | else
12568          :
12569  
12570  
12571 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12572 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12571 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12572 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12573   if test "${ac_pentiumpro+set}" = set; then
12574    echo $ECHO_N "(cached) $ECHO_C" >&6
12575   else
12576    echo 'void f(){}' > conftest.c
12577 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12577 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12578          ac_pentiumpro=yes
12579   else
12580          ac_pentiumpro=no
# Line 5571 | Line 12601 | fi
12601                  if test -n "$is60x"; then
12602  
12603  
12604 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12605 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12604 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12605 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12606   if test "${ac_m_cpu_60x+set}" = set; then
12607    echo $ECHO_N "(cached) $ECHO_C" >&6
12608   else
12609    echo 'void f(){}' > conftest.c
12610 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12610 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12611          ac_m_cpu_60x=yes
12612   else
12613          ac_m_cpu_60x=no
# Line 5629 | Line 12659 | if test "$ac_cv_prog_gcc_2_95" = yes; then
12659          :
12660  
12661  
12662 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12663 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12662 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12663 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12664   if test "${ac_m_cpu_750+set}" = set; then
12665    echo $ECHO_N "(cached) $ECHO_C" >&6
12666   else
12667    echo 'void f(){}' > conftest.c
12668 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12668 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12669          ac_m_cpu_750=yes
12670   else
12671          ac_m_cpu_750=no
# Line 5662 | Line 12692 | fi
12692                  if test -z "$CPU_FLAGS"; then
12693  
12694  
12695 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12696 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12695 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12696 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12697   if test "${ac_m_cpu_powerpc+set}" = set; then
12698    echo $ECHO_N "(cached) $ECHO_C" >&6
12699   else
12700    echo 'void f(){}' > conftest.c
12701 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12701 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12702          ac_m_cpu_powerpc=yes
12703   else
12704          ac_m_cpu_powerpc=no
# Line 5690 | Line 12720 | fi
12720                  if test -z "$CPU_FLAGS"; then
12721  
12722  
12723 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12724 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12723 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12724 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12725   if test "${ac_m_powerpc+set}" = set; then
12726    echo $ECHO_N "(cached) $ECHO_C" >&6
12727   else
12728    echo 'void f(){}' > conftest.c
12729 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12729 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12730          ac_m_powerpc=yes
12731   else
12732          ac_m_powerpc=no
# Line 5735 | Line 12765 | fi
12765  
12766  
12767  
12768 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12769 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12768 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12769 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12770   if test "${ac_guessed_cflags+set}" = set; then
12771    echo $ECHO_N "(cached) $ECHO_C" >&6
12772   else
12773    echo 'void f(){}' > conftest.c
12774 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12774 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12775          ac_guessed_cflags=yes
12776   else
12777          ac_guessed_cflags=no
# Line 5785 | Line 12815 | cat > conftest.cpp <<EOF
12815  
12816   cat > conftest.cpp <<EOF
12817   #ifdef __GNUC__
12818 <  #ifndef __INTEL_COMPILER
12818 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12819 >     no;
12820 >  #else
12821       yes;
12822    #endif
12823   #endif
# Line 5823 | Line 12855 | if test "$ac_test_CXXFLAGS" != "set"; then
12855                      CXXFLAGS="-O"
12856                  fi;;
12857    sparc-solaris2*) if test "$CXX" = CC; then
12858 <                    CXXFLAGS="-native -fast -xO5 -dalign"
12858 >                    CXXFLAGS="-features=extensions -O -dalign"
12859                   fi;;
12860     rs6000*-aix*)  if test "$CXX" = xlC; then
12861                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 5844 | Line 12876 | if test "$ac_test_CXXFLAGS" != "set"; then
12876     *darwin*)
12877          if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12878                  CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12879 +        fi
12880 +        if test "$CXX" = icpc; then
12881 +                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12882          fi;;
12883    esac
12884  
# Line 5857 | Line 12892 | if test "$ac_test_CXXFLAGS" != "set"; then
12892      # -malign-double for x86 systems
12893  
12894  
12895 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12896 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12895 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12896 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12897   if test "${ac_align_double+set}" = set; then
12898    echo $ECHO_N "(cached) $ECHO_C" >&6
12899   else
12900    echo 'void f(){}' > conftest.cpp
12901 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12901 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12902          ac_align_double=yes
12903   else
12904          ac_align_double=no
# Line 5884 | Line 12919 | fi
12919      # -fstrict-aliasing for gcc-2.95+
12920  
12921  
12922 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12923 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12922 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12923 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12924   if test "${ac_fstrict_aliasing+set}" = set; then
12925    echo $ECHO_N "(cached) $ECHO_C" >&6
12926   else
12927    echo 'void f(){}' > conftest.cpp
12928 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12928 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12929          ac_fstrict_aliasing=yes
12930   else
12931          ac_fstrict_aliasing=no
# Line 5915 | Line 12950 | fi
12950                    case "${host_cpu}" in
12951            i586*)
12952  
12953 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12954 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12953 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12954 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12955   if test "${ac_cpu_pentium+set}" = set; then
12956    echo $ECHO_N "(cached) $ECHO_C" >&6
12957   else
12958    echo 'void f(){}' > conftest.cpp
12959 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12959 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12960          ac_cpu_pentium=yes
12961   else
12962          ac_cpu_pentium=no
# Line 5938 | Line 12973 | else
12973          :
12974  
12975  
12976 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12977 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12976 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12977 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12978   if test "${ac_pentium+set}" = set; then
12979    echo $ECHO_N "(cached) $ECHO_C" >&6
12980   else
12981    echo 'void f(){}' > conftest.cpp
12982 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12982 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12983          ac_pentium=yes
12984   else
12985          ac_pentium=no
# Line 5967 | Line 13002 | fi
13002                    ;;
13003            i686*)
13004  
13005 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
13006 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13005 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
13006 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13007   if test "${ac_cpu_pentiumpro+set}" = set; then
13008    echo $ECHO_N "(cached) $ECHO_C" >&6
13009   else
13010    echo 'void f(){}' > conftest.cpp
13011 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13011 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13012          ac_cpu_pentiumpro=yes
13013   else
13014          ac_cpu_pentiumpro=no
# Line 5990 | Line 13025 | else
13025          :
13026  
13027  
13028 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
13029 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
13028 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
13029 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
13030   if test "${ac_pentiumpro+set}" = set; then
13031    echo $ECHO_N "(cached) $ECHO_C" >&6
13032   else
13033    echo 'void f(){}' > conftest.cpp
13034 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
13034 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
13035          ac_pentiumpro=yes
13036   else
13037          ac_pentiumpro=no
# Line 6023 | Line 13058 | fi
13058                  if test -n "$is60x"; then
13059  
13060  
13061 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
13062 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
13061 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
13062 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
13063   if test "${ac_m_cpu_60x+set}" = set; then
13064    echo $ECHO_N "(cached) $ECHO_C" >&6
13065   else
13066    echo 'void f(){}' > conftest.cpp
13067 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13067 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13068          ac_m_cpu_60x=yes
13069   else
13070          ac_m_cpu_60x=no
# Line 6081 | Line 13116 | if test "$ac_cv_prog_gxx_2_95" = yes; then
13116          :
13117  
13118  
13119 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
13120 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
13119 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
13120 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
13121   if test "${ac_m_cpu_750+set}" = set; then
13122    echo $ECHO_N "(cached) $ECHO_C" >&6
13123   else
13124    echo 'void f(){}' > conftest.cpp
13125 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
13125 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
13126          ac_m_cpu_750=yes
13127   else
13128          ac_m_cpu_750=no
# Line 6114 | Line 13149 | fi
13149                  if test -z "$CPU_FLAGS"; then
13150  
13151  
13152 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
13153 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
13152 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
13153 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
13154   if test "${ac_m_cpu_powerpc+set}" = set; then
13155    echo $ECHO_N "(cached) $ECHO_C" >&6
13156   else
13157    echo 'void f(){}' > conftest.cpp
13158 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
13158 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
13159          ac_m_cpu_powerpc=yes
13160   else
13161          ac_m_cpu_powerpc=no
# Line 6142 | Line 13177 | fi
13177                  if test -z "$CPU_FLAGS"; then
13178  
13179  
13180 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
13181 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
13180 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
13181 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
13182   if test "${ac_m_powerpc+set}" = set; then
13183    echo $ECHO_N "(cached) $ECHO_C" >&6
13184   else
13185    echo 'void f(){}' > conftest.cpp
13186 < if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
13186 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
13187          ac_m_powerpc=yes
13188   else
13189          ac_m_powerpc=no
# Line 6187 | Line 13222 | fi
13222  
13223  
13224  
13225 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
13226 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
13225 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
13226 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
13227   if test "${ac_guessed_cxxflags+set}" = set; then
13228    echo $ECHO_N "(cached) $ECHO_C" >&6
13229   else
13230    echo 'void f(){}' > conftest.cpp
13231 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
13231 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
13232          ac_guessed_cxxflags=yes
13233   else
13234          ac_guessed_cxxflags=no
# Line 6217 | Line 13252 | else
13252          echo "**********************************************************"
13253          echo ""
13254          CXXFLAGS=""
6220
6221 fi
6222
6223
6224 fi
6225
6226
6227
6228
6229
6230 # Try to determine "good" native compiler flags if none specified on command
6231 # line
6232
6233 if test x"$F90FLAGS" = x ; then
6234  F90FLAGS=""
6235  case "${host_cpu}-${host_os}" in
13255  
6237  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
6238                    F90FLAGS="-O"
6239                fi;;
6240   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
6241                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
6242                fi;;
6243   powerpc*-aix*)
6244        if test "$F90" = f90 -o "$F90" = xlf90; then
6245                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
6246                echo "*******************************************************"
6247                echo "*  You have AIX on an unknown powerpc system.  It is  *"
6248                echo "*  recommended that you use                           *"
6249                echo "*                                                     *"
6250                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
6251                echo "*                                 ^^^                 *"
6252                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
6253                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
6254                echo "*******************************************************"
6255        fi;;
6256   *darwin*)
6257        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
6258                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
6259        fi;;
6260  esac
6261
6262  if test -n "$CPU_FLAGS"; then
6263        F90FLAGS="$F90FLAGS $CPU_FLAGS"
6264  fi
6265
6266  if test -z "$F90FLAGS"; then
6267        echo ""
6268        echo "**********************************************************"
6269        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
6270        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6271        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
6272        echo "**********************************************************"
6273        echo ""
6274        F90FLAGS="-O3"
6275  fi
6276
6277
6278 echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
6279 echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
6280 if test "${ac_guessed_f90flags+set}" = set; then
6281  echo $ECHO_N "(cached) $ECHO_C" >&6
6282 else
6283
6284
6285
6286 ac_ext=f90
6287 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
6288 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6289 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
6290
6291 echo 'program main' > conftest.$ac_ext
6292 echo 'end program main' >> conftest.$ac_ext
6293 ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
6294 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6295  (eval $ac_compile) 2>&5
6296  ac_status=$?
6297  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6298  (exit $ac_status); }; then
6299        ac_guessed_f90flags=yes
6300 else
6301        ac_guessed_f90flags=no
13256   fi
6303 rm -f conftest*
6304 ac_ext=c
6305 ac_cpp='$CPP $CPPFLAGS'
6306 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6307 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6308 ac_compiler_gnu=$ac_cv_c_compiler_gnu
13257  
13258  
13259   fi
6312 echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
6313 echo "${ECHO_T}$ac_guessed_f90flags" >&6
6314 if test "$ac_guessed_f90flags" = yes; then
6315        :
13260  
6317 else
6318        :
6319
6320        echo ""
6321        echo "**********************************************************"
6322        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
6323        echo "* your compiler.                                         *"
6324        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6325        echo "**********************************************************"
6326        echo ""
6327        F90FLAGS=""
6328
6329 fi
6330
6331
6332 fi
6333
13261       ;;
6335 esac
6336
6337 # Find a good install program.  We prefer a C program (faster),
6338 # so one script is as good as another.  But avoid the broken or
6339 # incompatible versions:
6340 # SysV /etc/install, /usr/sbin/install
6341 # SunOS /usr/etc/install
6342 # IRIX /sbin/install
6343 # AIX /bin/install
6344 # AmigaOS /C/install, which installs bootblocks on floppy discs
6345 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
6346 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
6347 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
6348 # ./install, which can be erroneously created by make from ./install.sh.
6349 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
6350 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
6351 if test -z "$INSTALL"; then
6352 if test "${ac_cv_path_install+set}" = set; then
6353  echo $ECHO_N "(cached) $ECHO_C" >&6
6354 else
6355  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6356 for as_dir in $PATH
6357 do
6358  IFS=$as_save_IFS
6359  test -z "$as_dir" && as_dir=.
6360  # Account for people who put trailing slashes in PATH elements.
6361 case $as_dir/ in
6362  ./ | .// | /cC/* | \
6363  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
6364  /usr/ucb/* ) ;;
6365  *)
6366    # OSF1 and SCO ODT 3.0 have their own names for install.
6367    # Don't use installbsd from OSF since it installs stuff as root
6368    # by default.
6369    for ac_prog in ginstall scoinst install; do
6370      for ac_exec_ext in '' $ac_executable_extensions; do
6371        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
6372          if test $ac_prog = install &&
6373            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6374            # AIX install.  It has an incompatible calling convention.
6375            :
6376          elif test $ac_prog = install &&
6377            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6378            # program-specific install script used by HP pwplus--don't use.
6379            :
6380          else
6381            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
6382            break 3
6383          fi
6384        fi
6385      done
6386    done
6387    ;;
13262   esac
6389 done
13263  
13264  
6392 fi
6393  if test "${ac_cv_path_install+set}" = set; then
6394    INSTALL=$ac_cv_path_install
6395  else
6396    # As a last resort, use the slow shell script.  We don't cache a
6397    # path for INSTALL within a source directory, because that will
6398    # break other packages using the cache if that directory is
6399    # removed, or if the path is relative.
6400    INSTALL=$ac_install_sh
6401  fi
6402 fi
6403 echo "$as_me:$LINENO: result: $INSTALL" >&5
6404 echo "${ECHO_T}$INSTALL" >&6
6405
6406 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
6407 # It thinks the first close brace ends the variable substitution.
6408 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
6409
6410 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
6411
6412 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
6413
6414 echo "$as_me:$LINENO: checking whether ln -s works" >&5
6415 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
6416 LN_S=$as_ln_s
6417 if test "$LN_S" = "ln -s"; then
6418  echo "$as_me:$LINENO: result: yes" >&5
6419 echo "${ECHO_T}yes" >&6
6420 else
6421  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
6422 echo "${ECHO_T}no, using $LN_S" >&6
6423 fi
6424
6425 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6426 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
6427 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,./+-,__p_,'`
6428 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
6429  echo $ECHO_N "(cached) $ECHO_C" >&6
6430 else
6431  cat >conftest.make <<\_ACEOF
6432 all:
6433        @echo 'ac_maketemp="$(MAKE)"'
6434 _ACEOF
6435 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
6436 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
6437 if test -n "$ac_maketemp"; then
6438  eval ac_cv_prog_make_${ac_make}_set=yes
6439 else
6440  eval ac_cv_prog_make_${ac_make}_set=no
6441 fi
6442 rm -f conftest.make
6443 fi
6444 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
6445  echo "$as_me:$LINENO: result: yes" >&5
6446 echo "${ECHO_T}yes" >&6
6447  SET_MAKE=
6448 else
6449  echo "$as_me:$LINENO: result: no" >&5
6450 echo "${ECHO_T}no" >&6
6451  SET_MAKE="MAKE=${MAKE-make}"
6452 fi
6453
6454 if test -n "$ac_tool_prefix"; then
6455  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6456 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6457 echo "$as_me:$LINENO: checking for $ac_word" >&5
6458 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6459 if test "${ac_cv_prog_RANLIB+set}" = set; then
6460  echo $ECHO_N "(cached) $ECHO_C" >&6
6461 else
6462  if test -n "$RANLIB"; then
6463  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
6464 else
6465 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6466 for as_dir in $PATH
6467 do
6468  IFS=$as_save_IFS
6469  test -z "$as_dir" && as_dir=.
6470  for ac_exec_ext in '' $ac_executable_extensions; do
6471  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6472    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6473    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6474    break 2
6475  fi
6476 done
6477 done
6478
6479 fi
6480 fi
6481 RANLIB=$ac_cv_prog_RANLIB
6482 if test -n "$RANLIB"; then
6483  echo "$as_me:$LINENO: result: $RANLIB" >&5
6484 echo "${ECHO_T}$RANLIB" >&6
6485 else
6486  echo "$as_me:$LINENO: result: no" >&5
6487 echo "${ECHO_T}no" >&6
6488 fi
6489
6490 fi
6491 if test -z "$ac_cv_prog_RANLIB"; then
6492  ac_ct_RANLIB=$RANLIB
6493  # Extract the first word of "ranlib", so it can be a program name with args.
6494 set dummy ranlib; ac_word=$2
6495 echo "$as_me:$LINENO: checking for $ac_word" >&5
6496 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6497 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
6498  echo $ECHO_N "(cached) $ECHO_C" >&6
6499 else
6500  if test -n "$ac_ct_RANLIB"; then
6501  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
6502 else
6503 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6504 for as_dir in $PATH
6505 do
6506  IFS=$as_save_IFS
6507  test -z "$as_dir" && as_dir=.
6508  for ac_exec_ext in '' $ac_executable_extensions; do
6509  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6510    ac_cv_prog_ac_ct_RANLIB="ranlib"
6511    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6512    break 2
6513  fi
6514 done
6515 done
6516
6517  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
6518 fi
6519 fi
6520 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6521 if test -n "$ac_ct_RANLIB"; then
6522  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
6523 echo "${ECHO_T}$ac_ct_RANLIB" >&6
6524 else
6525  echo "$as_me:$LINENO: result: no" >&5
6526 echo "${ECHO_T}no" >&6
6527 fi
6528
6529  RANLIB=$ac_ct_RANLIB
6530 else
6531  RANLIB="$ac_cv_prog_RANLIB"
6532 fi
6533
6534 for ac_prog in 'bison -y' byacc
6535 do
6536  # Extract the first word of "$ac_prog", so it can be a program name with args.
6537 set dummy $ac_prog; ac_word=$2
6538 echo "$as_me:$LINENO: checking for $ac_word" >&5
6539 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6540 if test "${ac_cv_prog_YACC+set}" = set; then
6541  echo $ECHO_N "(cached) $ECHO_C" >&6
6542 else
6543  if test -n "$YACC"; then
6544  ac_cv_prog_YACC="$YACC" # Let the user override the test.
6545 else
6546 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6547 for as_dir in $PATH
6548 do
6549  IFS=$as_save_IFS
6550  test -z "$as_dir" && as_dir=.
6551  for ac_exec_ext in '' $ac_executable_extensions; do
6552  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6553    ac_cv_prog_YACC="$ac_prog"
6554    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6555    break 2
6556  fi
6557 done
6558 done
6559
6560 fi
6561 fi
6562 YACC=$ac_cv_prog_YACC
6563 if test -n "$YACC"; then
6564  echo "$as_me:$LINENO: result: $YACC" >&5
6565 echo "${ECHO_T}$YACC" >&6
6566 else
6567  echo "$as_me:$LINENO: result: no" >&5
6568 echo "${ECHO_T}no" >&6
6569 fi
6570
6571  test -n "$YACC" && break
6572 done
6573 test -n "$YACC" || YACC="yacc"
6574
6575 for ac_prog in flex lex
6576 do
6577  # Extract the first word of "$ac_prog", so it can be a program name with args.
6578 set dummy $ac_prog; ac_word=$2
6579 echo "$as_me:$LINENO: checking for $ac_word" >&5
6580 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6581 if test "${ac_cv_prog_LEX+set}" = set; then
6582  echo $ECHO_N "(cached) $ECHO_C" >&6
6583 else
6584  if test -n "$LEX"; then
6585  ac_cv_prog_LEX="$LEX" # Let the user override the test.
6586 else
6587 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6588 for as_dir in $PATH
6589 do
6590  IFS=$as_save_IFS
6591  test -z "$as_dir" && as_dir=.
6592  for ac_exec_ext in '' $ac_executable_extensions; do
6593  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6594    ac_cv_prog_LEX="$ac_prog"
6595    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6596    break 2
6597  fi
6598 done
6599 done
6600
6601 fi
6602 fi
6603 LEX=$ac_cv_prog_LEX
6604 if test -n "$LEX"; then
6605  echo "$as_me:$LINENO: result: $LEX" >&5
6606 echo "${ECHO_T}$LEX" >&6
6607 else
6608  echo "$as_me:$LINENO: result: no" >&5
6609 echo "${ECHO_T}no" >&6
6610 fi
6611
6612  test -n "$LEX" && break
6613 done
6614 test -n "$LEX" || LEX=":"
6615
6616 if test -z "$LEXLIB"
6617 then
6618  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
6619 echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
6620 if test "${ac_cv_lib_fl_yywrap+set}" = set; then
6621  echo $ECHO_N "(cached) $ECHO_C" >&6
6622 else
6623  ac_check_lib_save_LIBS=$LIBS
6624 LIBS="-lfl  $LIBS"
6625 cat >conftest.$ac_ext <<_ACEOF
6626 #line $LINENO "configure"
6627 /* confdefs.h.  */
6628 _ACEOF
6629 cat confdefs.h >>conftest.$ac_ext
6630 cat >>conftest.$ac_ext <<_ACEOF
6631 /* end confdefs.h.  */
6632
6633 /* Override any gcc2 internal prototype to avoid an error.  */
6634 #ifdef __cplusplus
6635 extern "C"
6636 #endif
6637 /* We use char because int might match the return type of a gcc2
6638   builtin and then its argument prototype would still apply.  */
6639 char yywrap ();
6640 int
6641 main ()
6642 {
6643 yywrap ();
6644  ;
6645  return 0;
6646 }
6647 _ACEOF
6648 rm -f conftest.$ac_objext conftest$ac_exeext
6649 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6650  (eval $ac_link) 2>&5
6651  ac_status=$?
6652  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6653  (exit $ac_status); } &&
6654         { ac_try='test -s conftest$ac_exeext'
6655  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6656  (eval $ac_try) 2>&5
6657  ac_status=$?
6658  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6659  (exit $ac_status); }; }; then
6660  ac_cv_lib_fl_yywrap=yes
6661 else
6662  echo "$as_me: failed program was:" >&5
6663 sed 's/^/| /' conftest.$ac_ext >&5
6664
6665 ac_cv_lib_fl_yywrap=no
6666 fi
6667 rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
6668 LIBS=$ac_check_lib_save_LIBS
6669 fi
6670 echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
6671 echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
6672 if test $ac_cv_lib_fl_yywrap = yes; then
6673  LEXLIB="-lfl"
6674 else
6675  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
6676 echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
6677 if test "${ac_cv_lib_l_yywrap+set}" = set; then
6678  echo $ECHO_N "(cached) $ECHO_C" >&6
6679 else
6680  ac_check_lib_save_LIBS=$LIBS
6681 LIBS="-ll  $LIBS"
6682 cat >conftest.$ac_ext <<_ACEOF
6683 #line $LINENO "configure"
6684 /* confdefs.h.  */
6685 _ACEOF
6686 cat confdefs.h >>conftest.$ac_ext
6687 cat >>conftest.$ac_ext <<_ACEOF
6688 /* end confdefs.h.  */
6689
6690 /* Override any gcc2 internal prototype to avoid an error.  */
6691 #ifdef __cplusplus
6692 extern "C"
6693 #endif
6694 /* We use char because int might match the return type of a gcc2
6695   builtin and then its argument prototype would still apply.  */
6696 char yywrap ();
6697 int
6698 main ()
6699 {
6700 yywrap ();
6701  ;
6702  return 0;
6703 }
6704 _ACEOF
6705 rm -f conftest.$ac_objext conftest$ac_exeext
6706 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6707  (eval $ac_link) 2>&5
6708  ac_status=$?
6709  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6710  (exit $ac_status); } &&
6711         { ac_try='test -s conftest$ac_exeext'
6712  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6713  (eval $ac_try) 2>&5
6714  ac_status=$?
6715  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6716  (exit $ac_status); }; }; then
6717  ac_cv_lib_l_yywrap=yes
6718 else
6719  echo "$as_me: failed program was:" >&5
6720 sed 's/^/| /' conftest.$ac_ext >&5
6721
6722 ac_cv_lib_l_yywrap=no
6723 fi
6724 rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
6725 LIBS=$ac_check_lib_save_LIBS
6726 fi
6727 echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
6728 echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
6729 if test $ac_cv_lib_l_yywrap = yes; then
6730  LEXLIB="-ll"
6731 fi
6732
6733 fi
6734
6735 fi
6736
6737 if test "x$LEX" != "x:"; then
6738  echo "$as_me:$LINENO: checking lex output file root" >&5
6739 echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
6740 if test "${ac_cv_prog_lex_root+set}" = set; then
6741  echo $ECHO_N "(cached) $ECHO_C" >&6
6742 else
6743  # The minimal lex program is just a single line: %%.  But some broken lexes
6744 # (Solaris, I think it was) want two %% lines, so accommodate them.
6745 cat >conftest.l <<_ACEOF
6746 %%
6747 %%
6748 _ACEOF
6749 { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
6750  (eval $LEX conftest.l) 2>&5
6751  ac_status=$?
6752  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6753  (exit $ac_status); }
6754 if test -f lex.yy.c; then
6755  ac_cv_prog_lex_root=lex.yy
6756 elif test -f lexyy.c; then
6757  ac_cv_prog_lex_root=lexyy
6758 else
6759  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
6760 echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
6761   { (exit 1); exit 1; }; }
6762 fi
6763 fi
6764 echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
6765 echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
6766 rm -f conftest.l
6767 LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
6768
6769 echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
6770 echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
6771 if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
6772  echo $ECHO_N "(cached) $ECHO_C" >&6
6773 else
6774  # POSIX says lex can declare yytext either as a pointer or an array; the
6775 # default is implementation-dependent. Figure out which it is, since
6776 # not all implementations provide the %pointer and %array declarations.
6777 ac_cv_prog_lex_yytext_pointer=no
6778 echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
6779 ac_save_LIBS=$LIBS
6780 LIBS="$LIBS $LEXLIB"
6781 cat >conftest.$ac_ext <<_ACEOF
6782 `cat $LEX_OUTPUT_ROOT.c`
6783 _ACEOF
6784 rm -f conftest.$ac_objext conftest$ac_exeext
6785 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6786  (eval $ac_link) 2>&5
6787  ac_status=$?
6788  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6789  (exit $ac_status); } &&
6790         { ac_try='test -s conftest$ac_exeext'
6791  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6792  (eval $ac_try) 2>&5
6793  ac_status=$?
6794  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6795  (exit $ac_status); }; }; then
6796  ac_cv_prog_lex_yytext_pointer=yes
6797 else
6798  echo "$as_me: failed program was:" >&5
6799 sed 's/^/| /' conftest.$ac_ext >&5
6800
6801 fi
6802 rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
6803 LIBS=$ac_save_LIBS
6804 rm -f "${LEX_OUTPUT_ROOT}.c"
6805
6806 fi
6807 echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
6808 echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
6809 if test $ac_cv_prog_lex_yytext_pointer = yes; then
6810
13265   cat >>confdefs.h <<\_ACEOF
13266 < #define YYTEXT_POINTER 1
6813 < _ACEOF
6814 <
6815 < fi
6816 <
6817 < fi
6818 < # Extract the first word of "ar", so it can be a program name with args.
6819 < set dummy ar; ac_word=$2
6820 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6821 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6822 < if test "${ac_cv_prog_AR+set}" = set; then
6823 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6824 < else
6825 <  if test -n "$AR"; then
6826 <  ac_cv_prog_AR="$AR" # Let the user override the test.
6827 < else
6828 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6829 < for as_dir in $PATH
6830 < do
6831 <  IFS=$as_save_IFS
6832 <  test -z "$as_dir" && as_dir=.
6833 <  for ac_exec_ext in '' $ac_executable_extensions; do
6834 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6835 <    ac_cv_prog_AR="ar"
6836 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6837 <    break 2
6838 <  fi
6839 < done
6840 < done
6841 <
6842 <  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
6843 < fi
6844 < fi
6845 < AR=$ac_cv_prog_AR
6846 < if test -n "$AR"; then
6847 <  echo "$as_me:$LINENO: result: $AR" >&5
6848 < echo "${ECHO_T}$AR" >&6
6849 < else
6850 <  echo "$as_me:$LINENO: result: no" >&5
6851 < echo "${ECHO_T}no" >&6
6852 < fi
6853 <
6854 < if test "$AR" = "NONE"; then
6855 <  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
6856 < echo "$as_me: error: --> Can't find \`ar'!" >&2;}
6857 <   { (exit 1); exit 1; }; }
6858 <  cat >confcache <<\_ACEOF
6859 < # This file is a shell script that caches the results of configure
6860 < # tests run on this system so they can be shared between configure
6861 < # scripts and configure runs, see configure's option --config-cache.
6862 < # It is not useful on other systems.  If it contains results you don't
6863 < # want to keep, you may remove or edit it.
6864 < #
6865 < # config.status only pays attention to the cache file if you give it
6866 < # the --recheck option to rerun configure.
6867 < #
6868 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
6869 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
6870 < # following values.
6871 <
6872 < _ACEOF
6873 <
6874 < # The following way of writing the cache mishandles newlines in values,
6875 < # but we know of no workaround that is simple, portable, and efficient.
6876 < # So, don't put newlines in cache variables' values.
6877 < # Ultrix sh set writes to stderr and can't be redirected directly,
6878 < # and sets the high bit in the cache file unless we assign to the vars.
6879 < {
6880 <  (set) 2>&1 |
6881 <    case `(ac_space=' '; set | grep ac_space) 2>&1` in
6882 <    *ac_space=\ *)
6883 <      # `set' does not quote correctly, so add quotes (double-quote
6884 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
6885 <      sed -n \
6886 <        "s/'/'\\\\''/g;
6887 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
6888 <      ;;
6889 <    *)
6890 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
6891 <      sed -n \
6892 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
6893 <      ;;
6894 <    esac;
6895 < } |
6896 <  sed '
6897 <     t clear
6898 <     : clear
6899 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
6900 <     t end
6901 <     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
6902 <     : end' >>confcache
6903 < if diff $cache_file confcache >/dev/null 2>&1; then :; else
6904 <  if test -w $cache_file; then
6905 <    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
6906 <    cat confcache >$cache_file
6907 <  else
6908 <    echo "not updating unwritable cache $cache_file"
6909 <  fi
6910 < fi
6911 < rm -f confcache
6912 <  exit 1
6913 < fi
6914 <
6915 < # Extract the first word of "ps", so it can be a program name with args.
6916 < set dummy ps; ac_word=$2
6917 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6918 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6919 < if test "${ac_cv_path_PS+set}" = set; then
6920 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6921 < else
6922 <  case $PS in
6923 <  [\\/]* | ?:[\\/]*)
6924 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
6925 <  ;;
6926 <  *)
6927 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6928 < for as_dir in $PATH
6929 < do
6930 <  IFS=$as_save_IFS
6931 <  test -z "$as_dir" && as_dir=.
6932 <  for ac_exec_ext in '' $ac_executable_extensions; do
6933 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6934 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
6935 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6936 <    break 2
6937 <  fi
6938 < done
6939 < done
6940 <
6941 <  ;;
6942 < esac
6943 < fi
6944 < PS=$ac_cv_path_PS
6945 <
6946 < if test -n "$PS"; then
6947 <  echo "$as_me:$LINENO: result: $PS" >&5
6948 < echo "${ECHO_T}$PS" >&6
6949 < else
6950 <  echo "$as_me:$LINENO: result: no" >&5
6951 < echo "${ECHO_T}no" >&6
6952 < fi
6953 <
6954 < echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
6955 < echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
6956 < if test "${ac_cv_prog_ps_syntax+set}" = set; then
6957 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6958 < else
6959 <
6960 <        if $PS -ef -o rss > /dev/null 2>&1; then
6961 <                ac_cv_prog_ps_ef=yes
6962 <        else
6963 <                ac_cv_prog_ps_ef=no
6964 <        fi
6965 <        if $PS ax -o rss > /dev/null 2>&1; then
6966 <                ac_cv_prog_ps_ax=yes
6967 <        else
6968 <                ac_cv_prog_ps_ax=no
6969 <        fi
6970 <        if test "$ac_cv_prog_ps_ef" = yes; then
6971 <                ac_cv_prog_ps_syntax=POSIX
6972 <        else
6973 <                if test "$ac_cv_prog_ps_ax" = yes; then
6974 <                        ac_cv_prog_ps_syntax=BSD
6975 <                else
6976 <                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
6977 < echo "$as_me: error: Could not determine ps syntax" >&2;}
6978 <   { (exit 1); exit 1; }; }
6979 <                fi
6980 <        fi
6981 <
6982 < fi
6983 < echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
6984 < echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
6985 <
6986 < cat >>confdefs.h <<_ACEOF
6987 < #define PS $PS
13266 > #define OBAPI
13267   _ACEOF
13268  
13269  
6991 cat >>confdefs.h <<_ACEOF
6992 #define PSTYPE $ac_cv_prog_ps_syntax
6993 _ACEOF
13270  
13271  
6996
6997
13272   # Check whether --with-mpi or --without-mpi was given.
13273   if test "${with_mpi+set}" = set; then
13274    withval="$with_mpi"
# Line 7023 | Line 13297 | have_mpi_h=0
13297   echo "$as_me:$LINENO: checking for mpi.h" >&5
13298   echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
13299   have_mpi_h=0
13300 + rm -f conftest*
13301   echo '#include <mpi.h>' > conftest.cc
13302 < if test -z "`${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1`"; then
13302 > if ${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1 ; then
13303          echo "$as_me:$LINENO: result: yes" >&5
13304   echo "${ECHO_T}yes" >&6
13305          have_mpi_h=1
13306   else
13307 +        if test -s conftest.out ; then
13308 +                cat conftest.out >> config.log
13309 +        fi
13310          echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
13311   echo "${ECHO_T}no! Check MPI include paths" >&6
13312          USE_MPI="no"
# Line 7046 | Line 13324 | rm -f conftest*
13324   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13325   have_mpif_h=0
13326   rm -f conftest*
13327 < cat >conftest.f90 <<EOF
13327 > cat >conftest.$ac_ext <<EOF
13328   program main
13329     include 'mpif.h'
13330   end
13331   EOF
13332 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13332 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13333          echo "$as_me:$LINENO: result: yes" >&5
13334   echo "${ECHO_T}yes" >&6
13335          MPI_F90_INC="$MPI_INC_DIR"
# Line 7092 | Line 13370 | cat >conftest.$ac_ext <<_ACEOF
13370    ac_check_lib_save_LIBS=$LIBS
13371   LIBS="-lmpich  $LIBS"
13372   cat >conftest.$ac_ext <<_ACEOF
7095 #line $LINENO "configure"
13373   /* confdefs.h.  */
13374   _ACEOF
13375   cat confdefs.h >>conftest.$ac_ext
# Line 7106 | Line 13383 | char MPI_Init ();
13383   /* We use char because int might match the return type of a gcc2
13384     builtin and then its argument prototype would still apply.  */
13385   char MPI_Init ();
13386 + #ifdef FC_DUMMY_MAIN
13387 + #ifndef FC_DUMMY_MAIN_EQ_F77
13388 + #  ifdef __cplusplus
13389 +     extern "C"
13390 + #  endif
13391 +   int FC_DUMMY_MAIN() { return 1; }
13392 + #endif
13393 + #endif
13394   int
13395   main ()
13396   {
# Line 7116 | Line 13401 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13401   _ACEOF
13402   rm -f conftest.$ac_objext conftest$ac_exeext
13403   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13404 <  (eval $ac_link) 2>&5
13404 >  (eval $ac_link) 2>conftest.er1
13405    ac_status=$?
13406 +  grep -v '^ *+' conftest.er1 >conftest.err
13407 +  rm -f conftest.er1
13408 +  cat conftest.err >&5
13409    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13410    (exit $ac_status); } &&
13411 <         { ac_try='test -s conftest$ac_exeext'
13411 >         { ac_try='test -z "$ac_c_werror_flag"
13412 >                         || test ! -s conftest.err'
13413    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13414    (eval $ac_try) 2>&5
13415    ac_status=$?
13416    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13417 +  (exit $ac_status); }; } &&
13418 +         { ac_try='test -s conftest$ac_exeext'
13419 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13420 +  (eval $ac_try) 2>&5
13421 +  ac_status=$?
13422 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13423    (exit $ac_status); }; }; then
13424    ac_cv_lib_mpich_MPI_Init=yes
13425   else
# Line 7133 | Line 13428 | fi
13428  
13429   ac_cv_lib_mpich_MPI_Init=no
13430   fi
13431 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
13431 > rm -f conftest.err conftest.$ac_objext \
13432 >      conftest$ac_exeext conftest.$ac_ext
13433   LIBS=$ac_check_lib_save_LIBS
13434   fi
13435   echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
# Line 7152 | Line 13448 | cat >conftest.$ac_ext <<_ACEOF
13448    ac_check_lib_save_LIBS=$LIBS
13449   LIBS="-lmpi  $LIBS"
13450   cat >conftest.$ac_ext <<_ACEOF
7155 #line $LINENO "configure"
13451   /* confdefs.h.  */
13452   _ACEOF
13453   cat confdefs.h >>conftest.$ac_ext
# Line 7166 | Line 13461 | char MPI_Init ();
13461   /* We use char because int might match the return type of a gcc2
13462     builtin and then its argument prototype would still apply.  */
13463   char MPI_Init ();
13464 + #ifdef FC_DUMMY_MAIN
13465 + #ifndef FC_DUMMY_MAIN_EQ_F77
13466 + #  ifdef __cplusplus
13467 +     extern "C"
13468 + #  endif
13469 +   int FC_DUMMY_MAIN() { return 1; }
13470 + #endif
13471 + #endif
13472   int
13473   main ()
13474   {
# Line 7176 | Line 13479 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13479   _ACEOF
13480   rm -f conftest.$ac_objext conftest$ac_exeext
13481   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13482 <  (eval $ac_link) 2>&5
13482 >  (eval $ac_link) 2>conftest.er1
13483    ac_status=$?
13484 +  grep -v '^ *+' conftest.er1 >conftest.err
13485 +  rm -f conftest.er1
13486 +  cat conftest.err >&5
13487    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13488    (exit $ac_status); } &&
13489 <         { ac_try='test -s conftest$ac_exeext'
13489 >         { ac_try='test -z "$ac_c_werror_flag"
13490 >                         || test ! -s conftest.err'
13491    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13492    (eval $ac_try) 2>&5
13493    ac_status=$?
13494    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13495 +  (exit $ac_status); }; } &&
13496 +         { ac_try='test -s conftest$ac_exeext'
13497 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13498 +  (eval $ac_try) 2>&5
13499 +  ac_status=$?
13500 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13501    (exit $ac_status); }; }; then
13502    ac_cv_lib_mpi_MPI_Init=yes
13503   else
# Line 7193 | Line 13506 | fi
13506  
13507   ac_cv_lib_mpi_MPI_Init=no
13508   fi
13509 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
13509 > rm -f conftest.err conftest.$ac_objext \
13510 >      conftest$ac_exeext conftest.$ac_ext
13511   LIBS=$ac_check_lib_save_LIBS
13512   fi
13513   echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
# Line 7213 | Line 13527 | cat >conftest.$ac_ext <<_ACEOF
13527    ac_check_lib_save_LIBS=$LIBS
13528   LIBS="-lmpi "-llam" $LIBS"
13529   cat >conftest.$ac_ext <<_ACEOF
7216 #line $LINENO "configure"
13530   /* confdefs.h.  */
13531   _ACEOF
13532   cat confdefs.h >>conftest.$ac_ext
# Line 7227 | Line 13540 | char MPI_Init ();
13540   /* We use char because int might match the return type of a gcc2
13541     builtin and then its argument prototype would still apply.  */
13542   char MPI_Init ();
13543 + #ifdef FC_DUMMY_MAIN
13544 + #ifndef FC_DUMMY_MAIN_EQ_F77
13545 + #  ifdef __cplusplus
13546 +     extern "C"
13547 + #  endif
13548 +   int FC_DUMMY_MAIN() { return 1; }
13549 + #endif
13550 + #endif
13551   int
13552   main ()
13553   {
# Line 7237 | Line 13558 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13558   _ACEOF
13559   rm -f conftest.$ac_objext conftest$ac_exeext
13560   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13561 <  (eval $ac_link) 2>&5
13561 >  (eval $ac_link) 2>conftest.er1
13562    ac_status=$?
13563 +  grep -v '^ *+' conftest.er1 >conftest.err
13564 +  rm -f conftest.er1
13565 +  cat conftest.err >&5
13566    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13567    (exit $ac_status); } &&
13568 <         { ac_try='test -s conftest$ac_exeext'
13568 >         { ac_try='test -z "$ac_c_werror_flag"
13569 >                         || test ! -s conftest.err'
13570 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13571 >  (eval $ac_try) 2>&5
13572 >  ac_status=$?
13573 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13574 >  (exit $ac_status); }; } &&
13575 >         { ac_try='test -s conftest$ac_exeext'
13576    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13577    (eval $ac_try) 2>&5
13578    ac_status=$?
# Line 7254 | Line 13585 | fi
13585  
13586   ac_cv_lib_mpi_MPI_Init=no
13587   fi
13588 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
13588 > rm -f conftest.err conftest.$ac_objext \
13589 >      conftest$ac_exeext conftest.$ac_ext
13590   LIBS=$ac_check_lib_save_LIBS
13591   fi
13592   echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
# Line 7274 | Line 13606 | cat >conftest.$ac_ext <<_ACEOF
13606    ac_check_lib_save_LIBS=$LIBS
13607   LIBS="-lmpich "-lpmpich" $LIBS"
13608   cat >conftest.$ac_ext <<_ACEOF
7277 #line $LINENO "configure"
13609   /* confdefs.h.  */
13610   _ACEOF
13611   cat confdefs.h >>conftest.$ac_ext
# Line 7288 | Line 13619 | char MPI_Init ();
13619   /* We use char because int might match the return type of a gcc2
13620     builtin and then its argument prototype would still apply.  */
13621   char MPI_Init ();
13622 + #ifdef FC_DUMMY_MAIN
13623 + #ifndef FC_DUMMY_MAIN_EQ_F77
13624 + #  ifdef __cplusplus
13625 +     extern "C"
13626 + #  endif
13627 +   int FC_DUMMY_MAIN() { return 1; }
13628 + #endif
13629 + #endif
13630   int
13631   main ()
13632   {
# Line 7298 | Line 13637 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13637   _ACEOF
13638   rm -f conftest.$ac_objext conftest$ac_exeext
13639   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13640 <  (eval $ac_link) 2>&5
13640 >  (eval $ac_link) 2>conftest.er1
13641    ac_status=$?
13642 +  grep -v '^ *+' conftest.er1 >conftest.err
13643 +  rm -f conftest.er1
13644 +  cat conftest.err >&5
13645    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13646    (exit $ac_status); } &&
13647 <         { ac_try='test -s conftest$ac_exeext'
13647 >         { ac_try='test -z "$ac_c_werror_flag"
13648 >                         || test ! -s conftest.err'
13649    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13650    (eval $ac_try) 2>&5
13651    ac_status=$?
13652    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13653 +  (exit $ac_status); }; } &&
13654 +         { ac_try='test -s conftest$ac_exeext'
13655 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13656 +  (eval $ac_try) 2>&5
13657 +  ac_status=$?
13658 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13659    (exit $ac_status); }; }; then
13660    ac_cv_lib_mpich_MPI_Init=yes
13661   else
# Line 7315 | Line 13664 | fi
13664  
13665   ac_cv_lib_mpich_MPI_Init=no
13666   fi
13667 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
13667 > rm -f conftest.err conftest.$ac_objext \
13668 >      conftest$ac_exeext conftest.$ac_ext
13669   LIBS=$ac_check_lib_save_LIBS
13670   fi
13671   echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13672   echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13673   if test $ac_cv_lib_mpich_MPI_Init = yes; then
13674 <  MPI_LIB="-lmpich -lpmpich"
13674 >  MPI_LIB="-lpmpich -lmpich"
13675   fi
13676  
13677   fi
# Line 7336 | Line 13686 | cat >conftest.$ac_ext <<_ACEOF
13686    ac_check_lib_save_LIBS=$LIBS
13687   LIBS="-lmpi -llam -lpthread $LIBS"
13688   cat >conftest.$ac_ext <<_ACEOF
7339 #line $LINENO "configure"
13689   /* confdefs.h.  */
13690   _ACEOF
13691   cat confdefs.h >>conftest.$ac_ext
# Line 7350 | Line 13699 | char MPI_Init ();
13699   /* We use char because int might match the return type of a gcc2
13700     builtin and then its argument prototype would still apply.  */
13701   char MPI_Init ();
13702 + #ifdef FC_DUMMY_MAIN
13703 + #ifndef FC_DUMMY_MAIN_EQ_F77
13704 + #  ifdef __cplusplus
13705 +     extern "C"
13706 + #  endif
13707 +   int FC_DUMMY_MAIN() { return 1; }
13708 + #endif
13709 + #endif
13710   int
13711   main ()
13712   {
# Line 7360 | Line 13717 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13717   _ACEOF
13718   rm -f conftest.$ac_objext conftest$ac_exeext
13719   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13720 <  (eval $ac_link) 2>&5
13720 >  (eval $ac_link) 2>conftest.er1
13721    ac_status=$?
13722 +  grep -v '^ *+' conftest.er1 >conftest.err
13723 +  rm -f conftest.er1
13724 +  cat conftest.err >&5
13725    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13726    (exit $ac_status); } &&
13727 <         { ac_try='test -s conftest$ac_exeext'
13727 >         { ac_try='test -z "$ac_c_werror_flag"
13728 >                         || test ! -s conftest.err'
13729 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13730 >  (eval $ac_try) 2>&5
13731 >  ac_status=$?
13732 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13733 >  (exit $ac_status); }; } &&
13734 >         { ac_try='test -s conftest$ac_exeext'
13735    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13736    (eval $ac_try) 2>&5
13737    ac_status=$?
# Line 7377 | Line 13744 | fi
13744  
13745   ac_cv_lib_mpi_MPI_Init=no
13746   fi
13747 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
13747 > rm -f conftest.err conftest.$ac_objext \
13748 >      conftest$ac_exeext conftest.$ac_ext
13749   LIBS=$ac_check_lib_save_LIBS
13750   fi
13751   echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
# Line 7415 | Line 13783 | fi
13783  
13784  
13785  
7418 # Check whether --with-sprng or --without-sprng was given.
7419 if test "${with_sprng+set}" = set; then
7420  withval="$with_sprng"
7421  with_sprng=$withval
7422 else
7423  with_sprng="/usr/local"
7424 fi;
13786  
13787 < case "x$with_sprng" in
13788 <        xyes | "x")  USE_SPRNG=yes;;
7428 <        xno) USE_SPRNG=no ;;
7429 <        *) SPRNG="$with_sprng"; USE_SPRNG=yes ;;
7430 < esac
7431 < if test "$USE_SPRNG" = "yes" -a -z "$with_sprng"; then
7432 <        SPRNG="/usr/local"
7433 < fi
7434 < if test "$USE_SPRNG" = "yes"; then
13787 > USE_CGAL=no
13788 > cgal_makefile=auto
13789  
13790 + # Check whether --with-cgal-makefile or --without-cgal-makefile was given.
13791 + if test "${with_cgal_makefile+set}" = set; then
13792 +  withval="$with_cgal_makefile"
13793 +  cgal_makefile="$withval"
13794 + fi;
13795  
13796 < # Set variables...
7438 < SPRNG_LIB_DIR="$SPRNG/lib"
7439 < SPRNG_INC_DIR="$SPRNG/include"
13796 > if test "x$cgal_makefile" != xno; then
13797  
13798 +  if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
13799 +    cgal_makefile="$CGAL_MAKEFILE"
13800 +  fi
13801  
13802 +  echo "$as_me:$LINENO: checking for cgal_makefile: $cgal_makefile" >&5
13803 + echo $ECHO_N "checking for cgal_makefile: $cgal_makefile... $ECHO_C" >&6
13804  
13805 < echo "$as_me:$LINENO: checking for sprng.h" >&5
7444 < echo $ECHO_N "checking for sprng.h... $ECHO_C" >&6
7445 < have_sprng_h=0
7446 < echo '#include <sprng.h>' > conftest.cc
7447 < if test -z "`${CXX} -I${SPRNG_INC_DIR} -c conftest.cc 2>&1`"; then
7448 <        echo "$as_me:$LINENO: result: yes" >&5
7449 < echo "${ECHO_T}yes" >&6
7450 <        have_sprng_h=1
7451 < else
7452 <        echo "$as_me:$LINENO: result: no! Check SPRNG include path!" >&5
7453 < echo "${ECHO_T}no! Check SPRNG include path!" >&6
7454 <        USE_SPRNG="no"
7455 < fi
7456 < rm -f conftest*
7457 < if test "$have_sprng_h" = 1; then
13805 >  if test -f "$cgal_makefile"; then
13806  
13807 < cat >>confdefs.h <<\_ACEOF
13808 < #define HAVE_SPRNG_H 1
13809 < _ACEOF
13807 >    cat >config.tmp.Makefile <<EOF
13808 > include $cgal_makefile
13809 > default:
13810 >        @echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
13811 >        @echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
13812 >        @echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
13813 >        @echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13814 >        @echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13815 >        @echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
13816 >        @echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
13817 >        @echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13818 >        @echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13819 >        @echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
13820 >        @echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13821 >        @echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13822 > EOF
13823  
13824 < fi
13824 >    make -s -f config.tmp.Makefile
13825 >    . config.tmp.cgalvariables
13826  
13827 < ac_ext=c
7466 < ac_cpp='$CPP $CPPFLAGS'
7467 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7468 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7469 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
13827 >    rm -f config.tmp.Makefile config.tmp.cgalvariables
13828  
13829 < ac_save_LDFLAGS=$LDFLAGS
13830 < LDFLAGS="${LDFLAGS} -L${SPRNG_LIB_DIR} "
13829 >    if test "x$CGAL_INCLDIR" = "x"; then
13830 >      CGAL_INCLDIR=""
13831 >    fi
13832  
13833 < echo "$as_me:$LINENO: checking for init_rng in -lsprng" >&5
13834 < echo $ECHO_N "checking for init_rng in -lsprng... $ECHO_C" >&6
13835 < if test "${ac_cv_lib_sprng_init_rng+set}" = set; then
7477 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7478 < else
7479 <  ac_check_lib_save_LIBS=$LIBS
7480 < LIBS="-lsprng  $LIBS"
7481 < cat >conftest.$ac_ext <<_ACEOF
7482 < #line $LINENO "configure"
7483 < /* confdefs.h.  */
7484 < _ACEOF
7485 < cat confdefs.h >>conftest.$ac_ext
7486 < cat >>conftest.$ac_ext <<_ACEOF
7487 < /* end confdefs.h.  */
13833 >    if test "x$CGAL_LIBDIR" = "x"; then
13834 >      CGAL_LIBDIR=""
13835 >    fi
13836  
13837 < /* Override any gcc2 internal prototype to avoid an error.  */
13838 < #ifdef __cplusplus
13839 < extern "C"
7492 < #endif
7493 < /* We use char because int might match the return type of a gcc2
7494 <   builtin and then its argument prototype would still apply.  */
7495 < char init_rng ();
7496 < int
7497 < main ()
7498 < {
7499 < init_rng ();
7500 <  ;
7501 <  return 0;
7502 < }
7503 < _ACEOF
7504 < rm -f conftest.$ac_objext conftest$ac_exeext
7505 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7506 <  (eval $ac_link) 2>&5
7507 <  ac_status=$?
7508 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7509 <  (exit $ac_status); } &&
7510 <         { ac_try='test -s conftest$ac_exeext'
7511 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7512 <  (eval $ac_try) 2>&5
7513 <  ac_status=$?
7514 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7515 <  (exit $ac_status); }; }; then
7516 <  ac_cv_lib_sprng_init_rng=yes
7517 < else
7518 <  echo "$as_me: failed program was:" >&5
7519 < sed 's/^/| /' conftest.$ac_ext >&5
13837 >    if test "x$CGAL_RLIBDIR" = "x"; then
13838 >      CGAL_RLIBDIR=""
13839 >    fi
13840  
13841 < ac_cv_lib_sprng_init_rng=no
13842 < fi
13843 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
7524 < LIBS=$ac_check_lib_save_LIBS
7525 < fi
7526 < echo "$as_me:$LINENO: result: $ac_cv_lib_sprng_init_rng" >&5
7527 < echo "${ECHO_T}$ac_cv_lib_sprng_init_rng" >&6
7528 < if test $ac_cv_lib_sprng_init_rng = yes; then
7529 <  SPRNG_LIB="-lsprng"
7530 < else
13841 >    if test "x$LEDA_INCLDIR" = "x"; then
13842 >      LEDA_INCLDIR=""
13843 >    fi
13844  
13845 <             { { echo "$as_me:$LINENO: error: Didn't find libsprng; check path for SPRNG package first..." >&5
13846 < echo "$as_me: error: Didn't find libsprng; check path for SPRNG package first..." >&2;}
13847 <   { (exit 1); exit 1; }; }
7535 <             USE_SPRNG="no"
13845 >    if test "x$LEDA_LIBDIR" = "x"; then
13846 >      LEDA_LIBDIR=""
13847 >    fi
13848  
13849 < fi
13849 >    if test "x$LEDA_RLIBDIR" = "x"; then
13850 >      LEDA_RLIBDIR=""
13851 >    fi
13852  
13853 +    if test "x$GMP_INCLDIR" = "x"; then
13854 +      GMP_INCLDIR=""
13855 +    fi
13856  
13857 < if test "$USE_SPRNG" = "no"; then
13858 <  { { echo "$as_me:$LINENO: error: No working SPRNG library found" >&5
13859 < echo "$as_me: error: No working SPRNG library found" >&2;}
7543 <   { (exit 1); exit 1; }; }
7544 < fi
13857 >    if test "x$GMP_LIBDIR" = "x"; then
13858 >      GMP_LIBDIR=""
13859 >    fi
13860  
13861 <
13862 < fi
7548 <
7549 <
7550 <
7551 < echo "$as_me:$LINENO: checking if MKL is wanted" >&5
7552 < echo $ECHO_N "checking if MKL is wanted... $ECHO_C" >&6
7553 <
7554 < # Check whether --with-mkl or --without-mkl was given.
7555 < if test "${with_mkl+set}" = set; then
7556 <  withval="$with_mkl"
7557 <     echo "$as_me:$LINENO: result: yes" >&5
7558 < echo "${ECHO_T}yes" >&6
7559 <    for dir in $withval /usr/local/intel/mkl61 /opt/intel/mkl61; do
7560 <        mkldir="$dir"
7561 <        if test -f "$dir/include/mkl.h"; then
7562 <            found_mkl="yes";
7563 <            break;
7564 <        fi
7565 <    done
7566 <    if test x_$found_mkl != x_yes; then
7567 <        { { echo "$as_me:$LINENO: error: Cannot find MKL includes" >&5
7568 < echo "$as_me: error: Cannot find MKL includes" >&2;}
7569 <   { (exit 1); exit 1; }; }
7570 <    else
7571 <        printf "MKL includes found in $mkldir/include\n";
13861 >    if test "x$GMP_RLIBDIR" = "x"; then
13862 >      GMP_RLIBDIR=""
13863      fi
13864  
13865 +    echo "$as_me:$LINENO: result: CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&5
13866 + echo "${ECHO_T}CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&6
13867 +    echo "$as_me:$LINENO: result: CGAL_INCLDIR=       $CGAL_INCLDIR" >&5
13868 + echo "${ECHO_T}CGAL_INCLDIR=       $CGAL_INCLDIR" >&6
13869 +    echo "$as_me:$LINENO: result: CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&5
13870 + echo "${ECHO_T}CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&6
13871 +    echo "$as_me:$LINENO: result: CGAL_LIBDIR=        $CGAL_LIBDIR" >&5
13872 + echo "${ECHO_T}CGAL_LIBDIR=        $CGAL_LIBDIR" >&6
13873 +    echo "$as_me:$LINENO: result: CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&5
13874 + echo "${ECHO_T}CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&6
13875 +    echo "$as_me:$LINENO: result: LEDA_INCLDIR=       $LEDA_INCLDIR" >&5
13876 + echo "${ECHO_T}LEDA_INCLDIR=       $LEDA_INCLDIR" >&6
13877 +    echo "$as_me:$LINENO: result: LEDA_LIBDIR=        $LEDA_LIBDIR" >&5
13878 + echo "${ECHO_T}LEDA_LIBDIR=        $LEDA_LIBDIR" >&6
13879 +    echo "$as_me:$LINENO: result: GMP_INCLDIR=        $GMP_INCLDIR" >&5
13880 + echo "${ECHO_T}GMP_INCLDIR=        $GMP_INCLDIR" >&6
13881 +    echo "$as_me:$LINENO: result: GMP_LIBDIR=         $GMP_LIBDIR" >&5
13882 + echo "${ECHO_T}GMP_LIBDIR=         $GMP_LIBDIR" >&6
13883  
13884 +    ac_ext=cc
13885 + ac_cpp='$CXXCPP $CPPFLAGS'
13886 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13887 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13888 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13889  
13890 <  ac_ext=c
13891 < ac_cpp='$CPP $CPPFLAGS'
13892 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13893 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13894 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
13895 <
7582 <  ac_save_CPPFLAGS=$CPPFLAGS
7583 <  CPPFLAGS="${CPPFLAGS} -I${mkldir}/include"
7584 <  ac_save_LDFLAGS=$LDFLAGS
7585 <  LDFLAGS="${LDFLAGS} -L${mkldir}/lib/32 -lmkl -lvml -lguide"
7586 <  if test "${ac_cv_header_mkl_h+set}" = set; then
7587 <  echo "$as_me:$LINENO: checking for mkl.h" >&5
7588 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
7589 < if test "${ac_cv_header_mkl_h+set}" = set; then
13890 >    save_CXXFLAGS="$CXXFLAGS"
13891 >    CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13892 >    if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13893 >  echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13894 > echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13895 > if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13896    echo $ECHO_N "(cached) $ECHO_C" >&6
13897   fi
13898 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
13899 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
13898 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13899 > echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13900   else
13901    # Is the header compilable?
13902 < echo "$as_me:$LINENO: checking mkl.h usability" >&5
13903 < echo $ECHO_N "checking mkl.h usability... $ECHO_C" >&6
13902 > echo "$as_me:$LINENO: checking CGAL/Cartesian.h usability" >&5
13903 > echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
13904   cat >conftest.$ac_ext <<_ACEOF
7599 #line $LINENO "configure"
13905   /* confdefs.h.  */
13906   _ACEOF
13907   cat confdefs.h >>conftest.$ac_ext
13908   cat >>conftest.$ac_ext <<_ACEOF
13909   /* end confdefs.h.  */
13910   $ac_includes_default
13911 < #include <mkl.h>
13911 > #include <CGAL/Cartesian.h>
13912   _ACEOF
13913   rm -f conftest.$ac_objext
13914   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13915 <  (eval $ac_compile) 2>&5
13915 >  (eval $ac_compile) 2>conftest.er1
13916    ac_status=$?
13917 +  grep -v '^ *+' conftest.er1 >conftest.err
13918 +  rm -f conftest.er1
13919 +  cat conftest.err >&5
13920    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13921    (exit $ac_status); } &&
13922 <         { ac_try='test -s conftest.$ac_objext'
13922 >         { ac_try='test -z "$ac_cxx_werror_flag"
13923 >                         || test ! -s conftest.err'
13924    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13925    (eval $ac_try) 2>&5
13926    ac_status=$?
13927    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13928 +  (exit $ac_status); }; } &&
13929 +         { ac_try='test -s conftest.$ac_objext'
13930 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13931 +  (eval $ac_try) 2>&5
13932 +  ac_status=$?
13933 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13934    (exit $ac_status); }; }; then
13935    ac_header_compiler=yes
13936   else
# Line 7624 | Line 13939 | fi
13939  
13940   ac_header_compiler=no
13941   fi
13942 < rm -f conftest.$ac_objext conftest.$ac_ext
13942 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
13943   echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
13944   echo "${ECHO_T}$ac_header_compiler" >&6
13945  
13946   # Is the header present?
13947 < echo "$as_me:$LINENO: checking mkl.h presence" >&5
13948 < echo $ECHO_N "checking mkl.h presence... $ECHO_C" >&6
13947 > echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
13948 > echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
13949   cat >conftest.$ac_ext <<_ACEOF
7635 #line $LINENO "configure"
13950   /* confdefs.h.  */
13951   _ACEOF
13952   cat confdefs.h >>conftest.$ac_ext
13953   cat >>conftest.$ac_ext <<_ACEOF
13954   /* end confdefs.h.  */
13955 < #include <mkl.h>
13955 > #include <CGAL/Cartesian.h>
13956   _ACEOF
13957   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
13958    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 7649 | Line 13963 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
13963    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13964    (exit $ac_status); } >/dev/null; then
13965    if test -s conftest.err; then
13966 <    ac_cpp_err=$ac_c_preproc_warn_flag
13966 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
13967 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
13968    else
13969      ac_cpp_err=
13970    fi
# Line 7669 | Line 13984 | echo "${ECHO_T}$ac_header_preproc" >&6
13984   echo "${ECHO_T}$ac_header_preproc" >&6
13985  
13986   # So?  What about this header?
13987 < case $ac_header_compiler:$ac_header_preproc in
13988 <  yes:no )
13989 <    { echo "$as_me:$LINENO: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&5
13990 < echo "$as_me: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13991 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the preprocessor's result" >&5
13992 < echo "$as_me: WARNING: mkl.h: proceeding with the preprocessor's result" >&2;}
13993 <    (
7679 <      cat <<\_ASBOX
7680 < ## ------------------------------------ ##
7681 < ## Report this to bug-autoconf@gnu.org. ##
7682 < ## ------------------------------------ ##
7683 < _ASBOX
7684 <    ) |
7685 <      sed "s/^/$as_me: WARNING:     /" >&2
13987 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13988 >  yes:no: )
13989 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
13990 > echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13991 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
13992 > echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
13993 >    ac_header_preproc=yes
13994      ;;
13995 <  no:yes )
13996 <    { echo "$as_me:$LINENO: WARNING: mkl.h: present but cannot be compiled" >&5
13997 < echo "$as_me: WARNING: mkl.h: present but cannot be compiled" >&2;}
13998 <    { echo "$as_me:$LINENO: WARNING: mkl.h: check for missing prerequisite headers?" >&5
13999 < echo "$as_me: WARNING: mkl.h: check for missing prerequisite headers?" >&2;}
14000 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the preprocessor's result" >&5
14001 < echo "$as_me: WARNING: mkl.h: proceeding with the preprocessor's result" >&2;}
13995 >  no:yes:* )
13996 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&5
13997 > echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
13998 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
13999 > echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
14000 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
14001 > echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
14002 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
14003 > echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
14004 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
14005 > echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
14006 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
14007 > echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
14008      (
14009        cat <<\_ASBOX
14010 < ## ------------------------------------ ##
14011 < ## Report this to bug-autoconf@gnu.org. ##
14012 < ## ------------------------------------ ##
14010 > ## ------------------------------ ##
14011 > ## Report this to gezelter@nd.edu ##
14012 > ## ------------------------------ ##
14013   _ASBOX
14014      ) |
14015        sed "s/^/$as_me: WARNING:     /" >&2
14016      ;;
14017   esac
14018 < echo "$as_me:$LINENO: checking for mkl.h" >&5
14019 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
14020 < if test "${ac_cv_header_mkl_h+set}" = set; then
14018 > echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
14019 > echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
14020 > if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
14021    echo $ECHO_N "(cached) $ECHO_C" >&6
14022   else
14023 <  ac_cv_header_mkl_h=$ac_header_preproc
14023 >  ac_cv_header_CGAL_Cartesian_h=$ac_header_preproc
14024   fi
14025 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
14026 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
14025 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
14026 > echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
14027  
14028   fi
14029 < if test $ac_cv_header_mkl_h = yes; then
14030 <
7717 <    echo "$as_me:$LINENO: checking for vslNewStream in -lmkl" >&5
7718 < echo $ECHO_N "checking for vslNewStream in -lmkl... $ECHO_C" >&6
7719 < if test "${ac_cv_lib_mkl_vslNewStream+set}" = set; then
7720 <  echo $ECHO_N "(cached) $ECHO_C" >&6
14029 > if test $ac_cv_header_CGAL_Cartesian_h = yes; then
14030 >  cgal=yes
14031   else
14032 <  ac_check_lib_save_LIBS=$LIBS
14033 < LIBS="-lmkl  $LIBS"
14032 >  cgal=no
14033 > fi
14034 >
14035 >
14036 >    CXXFLAGS="$save_CXXFLAGS"
14037 >
14038 >    if test "x$cgal" = xyes; then
14039 >      echo "$as_me:$LINENO: checking for CGAL version" >&5
14040 > echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
14041 >      LOCATION=${CGAL_INCLDIR}
14042 >      LOCATION=${LOCATION:-/usr/include}
14043 >      if test -f $LOCATION/CGAL/version.h; then
14044 >        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
14045 >      else
14046 >        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
14047 >      fi
14048 >      if echo $CGAL_VERSION | grep -q "^[3456789]"; then
14049 >        echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
14050 > echo "${ECHO_T}($CGAL_VERSION) yes" >&6
14051 >      else
14052 >        echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
14053 > echo "${ECHO_T}($CGAL_VERSION) no" >&6
14054 >        cgal=no
14055 >      fi
14056 >    fi
14057 >
14058 >    if test "x$cgal" = xyes; then
14059 >      CGAL_LIBS="-lCGAL"
14060 >      echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
14061 > echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
14062 >      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
14063 >        CGAL_USES_LEDA=yes
14064 >        echo "$as_me:$LINENO: result: yes" >&5
14065 > echo "${ECHO_T}yes" >&6
14066 >        CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
14067 >      else
14068 >        echo "$as_me:$LINENO: result: no" >&5
14069 > echo "${ECHO_T}no" >&6
14070 >        CGAL_USES_LEDA=no
14071 >      fi
14072 >
14073 >      echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
14074 > echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
14075 >      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
14076 >        CGAL_USES_GMP=yes
14077 >        echo "$as_me:$LINENO: result: yes" >&5
14078 > echo "${ECHO_T}yes" >&6
14079 >        CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
14080 >      else
14081 >        echo "$as_me:$LINENO: result: no" >&5
14082 > echo "${ECHO_T}no" >&6
14083 >        CGAL_USES_GMP=no
14084 >      fi
14085 >
14086 >      CGAL_LIBS="$CGAL_LIBS -lm"
14087 >
14088 >      CGAL_CXXFLAGS="-ftemplate-depth-50"
14089 >
14090 >      echo "$as_me:$LINENO: result: CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&5
14091 > echo "${ECHO_T}CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&6
14092 >      echo "$as_me:$LINENO: result: CGAL_USES_GMP =     $CGAL_USES_GMP" >&5
14093 > echo "${ECHO_T}CGAL_USES_GMP =     $CGAL_USES_GMP" >&6
14094 >      echo "$as_me:$LINENO: result: CGAL_INCLDIR  =     $CGAL_INCLDIR" >&5
14095 > echo "${ECHO_T}CGAL_INCLDIR  =     $CGAL_INCLDIR" >&6
14096 >      echo "$as_me:$LINENO: result: CGAL_LIBDIR   =     $CGAL_LIBDIR" >&5
14097 > echo "${ECHO_T}CGAL_LIBDIR   =     $CGAL_LIBDIR" >&6
14098 >      echo "$as_me:$LINENO: result: CGAL_DEFINES  =     $CGAL_DEFINES" >&5
14099 > echo "${ECHO_T}CGAL_DEFINES  =     $CGAL_DEFINES" >&6
14100 >      echo "$as_me:$LINENO: result: CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&5
14101 > echo "${ECHO_T}CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&6
14102 >      echo "$as_me:$LINENO: result: CGAL_LIBS     =     $CGAL_LIBS" >&5
14103 > echo "${ECHO_T}CGAL_LIBS     =     $CGAL_LIBS" >&6
14104 >    fi
14105 >
14106 >    if test "x$cgal" = xyes; then
14107 >      save_LIBS="$LIBS"
14108 >      LIBS="$LIBS -L$CGAL_LIBDIR"
14109 >      if test "x$CGAL_USES_LEDA" = xyes; then
14110 >        LIBS="-lL $LIBS -L$LEDA_LIBDIR"
14111 >      fi
14112 >      # if test "x$CGAL_USES_GMP" = xyes; then
14113 >      #   LIBS="-lgmp $LIBS $GMP_LIBDIR"
14114 >      # fi
14115 >      echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
14116 > echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
14117 > save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
14118 > CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
14119 > save_LIBS_CHECK_CXX_LIB="$LIBS"
14120 > LIBS="-lCGAL  $LIBS"
14121   cat >conftest.$ac_ext <<_ACEOF
7725 #line $LINENO "configure"
14122   /* confdefs.h.  */
14123   _ACEOF
14124   cat confdefs.h >>conftest.$ac_ext
14125   cat >>conftest.$ac_ext <<_ACEOF
14126   /* end confdefs.h.  */
14127 <
14128 < /* Override any gcc2 internal prototype to avoid an error.  */
14129 < #ifdef __cplusplus
14130 < extern "C"
14127 > #include <CGAL/Cartesian.h>
14128 > #ifdef FC_DUMMY_MAIN
14129 > #ifndef FC_DUMMY_MAIN_EQ_F77
14130 > #  ifdef __cplusplus
14131 >     extern "C"
14132 > #  endif
14133 >   int FC_DUMMY_MAIN() { return 1; }
14134   #endif
14135 < /* We use char because int might match the return type of a gcc2
7737 <   builtin and then its argument prototype would still apply.  */
7738 < char vslNewStream ();
14135 > #endif
14136   int
14137   main ()
14138   {
14139 < vslNewStream ();
14139 > ::CGAL::Cartesian<int>::Point_2 P
14140    ;
14141    return 0;
14142   }
14143   _ACEOF
14144   rm -f conftest.$ac_objext conftest$ac_exeext
14145   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14146 <  (eval $ac_link) 2>&5
14146 >  (eval $ac_link) 2>conftest.er1
14147    ac_status=$?
14148 +  grep -v '^ *+' conftest.er1 >conftest.err
14149 +  rm -f conftest.er1
14150 +  cat conftest.err >&5
14151    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14152    (exit $ac_status); } &&
14153 <         { ac_try='test -s conftest$ac_exeext'
14153 >         { ac_try='test -z "$ac_cxx_werror_flag"
14154 >                         || test ! -s conftest.err'
14155    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14156    (eval $ac_try) 2>&5
14157    ac_status=$?
14158    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14159 +  (exit $ac_status); }; } &&
14160 +         { ac_try='test -s conftest$ac_exeext'
14161 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14162 +  (eval $ac_try) 2>&5
14163 +  ac_status=$?
14164 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14165    (exit $ac_status); }; }; then
14166 <  ac_cv_lib_mkl_vslNewStream=yes
14166 >  echo "$as_me:$LINENO: result: yes" >&5
14167 > echo "${ECHO_T}yes" >&6
14168 > cgal=yes
14169   else
14170    echo "$as_me: failed program was:" >&5
14171   sed 's/^/| /' conftest.$ac_ext >&5
14172  
14173 < ac_cv_lib_mkl_vslNewStream=no
14174 < fi
14175 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
7767 < LIBS=$ac_check_lib_save_LIBS
7768 < fi
7769 < echo "$as_me:$LINENO: result: $ac_cv_lib_mkl_vslNewStream" >&5
7770 < echo "${ECHO_T}$ac_cv_lib_mkl_vslNewStream" >&6
7771 < if test $ac_cv_lib_mkl_vslNewStream = yes; then
7772 <  MKL_LIBDIR="${mkldir}/lib/32",
7773 <                     MKL_LIB="-lmkl -lvml -lguide",
7774 <                     HAVE_MKL="yes"
7775 < fi
7776 <
7777 <
7778 < else
7779 <  MKL_INC="-I${mkldir}/include"
14173 > echo "$as_me:$LINENO: result: no" >&5
14174 > echo "${ECHO_T}no" >&6
14175 > cgal=no
14176   fi
14177 + rm -f conftest.err conftest.$ac_objext \
14178 +      conftest$ac_exeext conftest.$ac_ext
14179 + CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
14180 + LIBS="$save_LIBS_CHECK_CXX_LIB"
14181 +      LIBS="$save_LIBS"
14182 +    fi
14183  
14184 <
7783 <  CPPFLAGS=$ac_save_CPPFLAGS
7784 <  LDFLAGS=$ac_save_LDFLAGS
14184 >  fi
14185    ac_ext=c
14186   ac_cpp='$CPP $CPPFLAGS'
14187   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 7789 | Line 14189 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
14189   ac_compiler_gnu=$ac_cv_c_compiler_gnu
14190  
14191  
14192 <  if test x_$HAVE_MKL != x_yes; then
7793 <        { { echo "$as_me:$LINENO: error: Can't build with MKL" >&5
7794 < echo "$as_me: error: Can't build with MKL" >&2;}
7795 <   { (exit 1); exit 1; }; }
7796 <  fi
14192 > fi
14193  
14194 + if test "x$cgal" = xyes; then
14195 +  USE_CGAL=yes
14196  
14197 + cat >>confdefs.h <<\_ACEOF
14198 + #define HAVE_CGAL 1
14199 + _ACEOF
14200  
14201  
14202 + cat >>confdefs.h <<_ACEOF
14203 + #define CGAL_VERSION $CGAL_VERSION
14204 + _ACEOF
14205  
14206 +  if ! echo $CGAL_VERSION | grep -q "^3.0"; then
14207 +    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
14208 + echo "$as_me: WARNING: *****************************************************" >&2;}
14209 +    { echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
14210 + echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
14211 +    { echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
14212 + echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
14213 +    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
14214 + echo "$as_me: WARNING: *****************************************************" >&2;}
14215 +  fi
14216   else
14217 +   if test "x$cgal_makefile" != xno; then
14218 +    echo "$as_me:$LINENO: result: No CGAL support. These are not the droids you want." >&5
14219 + echo "${ECHO_T}No CGAL support. These are not the droids you want." >&6
14220 +  fi
14221 +  CGAL_INCLDIR=
14222 +  CGAL_LIBDIR=
14223 +  CGAL_RLIBDIR=
14224 +  CGAL_DEFINES=
14225 +  CGAL_CXXFLAGS=
14226 +  CGAL_LIBS=
14227 + fi
14228  
7804    echo "$as_me:$LINENO: result: no" >&5
7805 echo "${ECHO_T}no" >&6
14229  
14230 < fi;
14230 > CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
14231  
14232 + CGAL_LIB_DIR=${CGAL_LIBDIR}
14233  
14234 + CGAL_RLIB_DIR=${CGAL_RLIBDIR}
14235  
14236 +
14237 +
14238 +
14239 +
14240 +
14241 +
14242   # Check whether --enable-doxygen or --disable-doxygen was given.
14243   if test "${enable_doxygen+set}" = set; then
14244    enableval="$enable_doxygen"
# Line 7949 | Line 14380 | fi
14380  
14381  
14382  
7952 OBJEXT=".$OBJEXT"
14383  
7954 OOPSE=oopse
14384  
7956 if test "x${prefix}" = "xNONE"
7957 then
7958  OOPSE_HOME=${ac_default_prefix}/oopse
7959 else
7960  OOPSE_HOME=${prefix}/oopse
7961 fi
7962 # Check whether --enable-oopse-home or --disable-oopse-home was given.
7963 if test "${enable_oopse_home+set}" = set; then
7964  enableval="$enable_oopse_home"
7965  OOPSE_HOME="${enableval}"
7966 fi;
14385  
7968 case "x$INSTALL" in
7969   x/*) ;;
7970   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
7971 esac
14386  
7973 MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14387  
7975 CFLAGS=${CFLAGS-""}
7976 CXXFLAGS=${CXXFLAGS-""}
7977 CPPFLAGS=${CPPFLAGS-""}
7978 FFLAGS=${FFLAGS-""}
7979 F90FLAGS=${F90FLAGS-""}
7980 LDFLAGS=${LDFLAGS-""}
7981 DEBUG=${DEBUG-"-g"}
14388  
7983 case $debug in
7984  1)
7985     FFLAGS="$DEBUG $FFLAGS"
7986     F90FLAGS="$DEBUG $F90FLAGS"
7987     ;;
7988  *)
7989     ;;
7990 esac
14389  
14390  
14391  
14392  
14393  
14394  
14395 +                                        ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14396  
14397  
7999
8000
8001
8002
8003
8004
8005
8006
8007
8008
8009          ac_config_headers="$ac_config_headers src/config.h"
8010
8011                    ac_config_files="$ac_config_files make/Makefile src/utils/Makefile"
8012
8013
14398   cat >confcache <<\_ACEOF
14399   # This file is a shell script that caches the results of configure
14400   # tests run on this system so they can be shared between configure
# Line 8039 | Line 14423 | _ACEOF
14423        # `set' does not quote correctly, so add quotes (double-quote
14424        # substitution turns \\\\ into \\, and sed turns \\ into \).
14425        sed -n \
14426 <        "s/'/'\\\\''/g;
14427 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
14426 >        "s/'/'\\\\''/g;
14427 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
14428        ;;
14429      *)
14430        # `set' quotes correctly as required by POSIX, so do not add quotes.
14431        sed -n \
14432 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
14432 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
14433        ;;
14434      esac;
14435   } |
# Line 8075 | Line 14459 | if test "x$srcdir" = x.; then
14459   # trailing colons and then remove the whole line if VPATH becomes empty
14460   # (actually we leave an empty line to preserve line numbers).
14461   if test "x$srcdir" = x.; then
14462 <  ac_vpsub='/^[         ]*VPATH[        ]*=/{
14462 >  ac_vpsub='/^[  ]*VPATH[        ]*=/{
14463   s/:*\$(srcdir):*/:/;
14464   s/:*\${srcdir}:*/:/;
14465   s/:*@srcdir@:*/:/;
14466 < s/^\([^=]*=[    ]*\):*/\1/;
14466 > s/^\([^=]*=[     ]*\):*/\1/;
14467   s/:*$//;
14468 < s/^[^=]*=[      ]*$//;
14468 > s/^[^=]*=[       ]*$//;
14469   }'
14470   fi
14471  
# Line 8092 | Line 14476 | for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && conti
14476   for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
14477    # 1. Remove the extension, and $U if already installed.
14478    ac_i=`echo "$ac_i" |
14479 <         sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
14479 >         sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
14480    # 2. Add them.
14481    ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
14482    ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
# Line 8136 | Line 14520 | fi
14520   elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
14521    set -o posix
14522   fi
14523 + DUALCASE=1; export DUALCASE # for MKS sh
14524  
14525   # Support unset when possible.
14526 < if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
14526 > if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
14527    as_unset=unset
14528   else
14529    as_unset=false
# Line 8157 | Line 14542 | do
14542    LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
14543    LC_TELEPHONE LC_TIME
14544   do
14545 <  if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then
14545 >  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
14546      eval $as_var=C; export $as_var
14547    else
14548      $as_unset $as_var
# Line 8336 | Line 14721 | else
14721   if mkdir -p . 2>/dev/null; then
14722    as_mkdir_p=:
14723   else
14724 +  test -d ./-p && rmdir ./-p
14725    as_mkdir_p=false
14726   fi
14727  
14728   as_executable_p="test -f"
14729  
14730   # Sed expression to map a string onto a valid CPP name.
14731 < as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
14731 > as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
14732  
14733   # Sed expression to map a string onto a valid variable name.
14734 < as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
14734 > as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
14735  
14736  
14737   # IFS
# Line 8371 | Line 14757 | cat >&5 <<_CSEOF
14757   } >&5
14758   cat >&5 <<_CSEOF
14759  
14760 < This file was extended by OOPSE $as_me 2.0, which was
14761 < generated by GNU Autoconf 2.57.  Invocation command line was
14760 > This file was extended by OOPSE $as_me 3.0, which was
14761 > generated by GNU Autoconf 2.59.  Invocation command line was
14762  
14763    CONFIG_FILES    = $CONFIG_FILES
14764    CONFIG_HEADERS  = $CONFIG_HEADERS
# Line 8416 | Line 14802 | Usage: $0 [OPTIONS] [FILE]...
14802    -d, --debug      don't remove temporary files
14803        --recheck    update $as_me by reconfiguring in the same conditions
14804    --file=FILE[:TEMPLATE]
14805 <                   instantiate the configuration file FILE
14805 >                   instantiate the configuration file FILE
14806    --header=FILE[:TEMPLATE]
14807 <                   instantiate the configuration header FILE
14807 >                   instantiate the configuration header FILE
14808  
14809   Configuration files:
14810   $config_files
# Line 8434 | Line 14820 | ac_cs_version="\\
14820  
14821   cat >>$CONFIG_STATUS <<_ACEOF
14822   ac_cs_version="\\
14823 < OOPSE config.status 2.0
14824 < configured by $0, generated by GNU Autoconf 2.57,
14823 > OOPSE config.status 3.0
14824 > configured by $0, generated by GNU Autoconf 2.59,
14825    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14826  
14827 < Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
8442 < Free Software Foundation, Inc.
14827 > Copyright (C) 2003 Free Software Foundation, Inc.
14828   This config.status script is free software; the Free Software Foundation
14829   gives unlimited permission to copy, distribute and modify it."
14830   srcdir=$srcdir
# Line 8540 | Line 14925 | do
14925    # Handling of arguments.
14926    "make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14927    "src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
14928 +  "src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
14929 +  "scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
14930    "src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
14931    "src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
14932    *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
# Line 8627 | Line 15014 | s,@LIBS@,$LIBS,;t t
15014   s,@ECHO_N@,$ECHO_N,;t t
15015   s,@ECHO_T@,$ECHO_T,;t t
15016   s,@LIBS@,$LIBS,;t t
8630 s,@PROGNAME@,$PROGNAME,;t t
8631 s,@debug@,$debug,;t t
15017   s,@build@,$build,;t t
15018   s,@build_cpu@,$build_cpu,;t t
15019   s,@build_vendor@,$build_vendor,;t t
# Line 8637 | Line 15022 | s,@host_os@,$host_os,;t t
15022   s,@host_cpu@,$host_cpu,;t t
15023   s,@host_vendor@,$host_vendor,;t t
15024   s,@host_os@,$host_os,;t t
15025 < s,@CC@,$CC,;t t
15026 < s,@CFLAGS@,$CFLAGS,;t t
15025 > s,@PROGNAME@,$PROGNAME,;t t
15026 > s,@debug@,$debug,;t t
15027 > s,@CXX@,$CXX,;t t
15028 > s,@CXXFLAGS@,$CXXFLAGS,;t t
15029   s,@LDFLAGS@,$LDFLAGS,;t t
15030   s,@CPPFLAGS@,$CPPFLAGS,;t t
15031 < s,@ac_ct_CC@,$ac_ct_CC,;t t
15031 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15032   s,@EXEEXT@,$EXEEXT,;t t
15033   s,@OBJEXT@,$OBJEXT,;t t
15034 < s,@CXX@,$CXX,;t t
15035 < s,@CXXFLAGS@,$CXXFLAGS,;t t
15036 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15037 < s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
15038 < s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
15039 < s,@F90@,$F90,;t t
8653 < s,@F90FLAGS@,$F90FLAGS,;t t
8654 < s,@ac_ct_F90@,$ac_ct_F90,;t t
8655 < s,@PREPFLAG@,$PREPFLAG,;t t
8656 < s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
8657 < s,@F90LIBS@,$F90LIBS,;t t
8658 < s,@F90_FUNC@,$F90_FUNC,;t t
8659 < s,@F90_FUNC_@,$F90_FUNC_,;t t
8660 < s,@MOD@,$MOD,;t t
8661 < s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
8662 < s,@MODDIRFLAG@,$MODDIRFLAG,;t t
8663 < s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
8664 < s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15034 > s,@CC@,$CC,;t t
15035 > s,@CFLAGS@,$CFLAGS,;t t
15036 > s,@ac_ct_CC@,$ac_ct_CC,;t t
15037 > s,@FC@,$FC,;t t
15038 > s,@FCFLAGS@,$FCFLAGS,;t t
15039 > s,@ac_ct_FC@,$ac_ct_FC,;t t
15040   s,@CPP@,$CPP,;t t
15041   s,@EGREP@,$EGREP,;t t
8667 s,@LIBOBJS@,$LIBOBJS,;t t
8668 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
8669 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
8670 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15042   s,@LN_S@,$LN_S,;t t
15043   s,@SET_MAKE@,$SET_MAKE,;t t
15044   s,@RANLIB@,$RANLIB,;t t
15045   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
15046 < s,@YACC@,$YACC,;t t
15047 < s,@LEX@,$LEX,;t t
15048 < s,@LEXLIB@,$LEXLIB,;t t
15049 < s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
15046 > s,@PERLINTERP@,$PERLINTERP,;t t
15047 > s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
15048 > s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
15049 > s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
15050 > s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15051   s,@AR@,$AR,;t t
15052   s,@PS@,$PS,;t t
15053 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
15054 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
15055 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
15056 + s,@FCLIBS@,$FCLIBS,;t t
15057 + s,@FC_FUNC@,$FC_FUNC,;t t
15058 + s,@FC_FUNC_@,$FC_FUNC_,;t t
15059 + s,@MOD@,$MOD,;t t
15060 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
15061 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
15062 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
15063 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15064 + s,@LIBOBJS@,$LIBOBJS,;t t
15065 + s,@POW_LIB@,$POW_LIB,;t t
15066 + s,@CXXCPP@,$CXXCPP,;t t
15067 + s,@__func__@,$__func__,;t t
15068   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
15069   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
15070   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
15071   s,@MPI_LIB@,$MPI_LIB,;t t
15072   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
15073   s,@USE_MPI@,$USE_MPI,;t t
15074 < s,@SPRNG_LIB_DIR@,$SPRNG_LIB_DIR,;t t
15075 < s,@SPRNG_INC_DIR@,$SPRNG_INC_DIR,;t t
15076 < s,@SPRNG_LIB@,$SPRNG_LIB,;t t
15077 < s,@USE_SPRNG@,$USE_SPRNG,;t t
15078 < s,@MKL_LIBDIR@,$MKL_LIBDIR,;t t
15079 < s,@MKL_LIB@,$MKL_LIB,;t t
15080 < s,@MKL_INC@,$MKL_INC,;t t
8694 < s,@HAVE_MKL@,$HAVE_MKL,;t t
15074 > s,@USE_CGAL@,$USE_CGAL,;t t
15075 > s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
15076 > s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
15077 > s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
15078 > s,@CGAL_DEFINES@,$CGAL_DEFINES,;t t
15079 > s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
15080 > s,@CGAL_LIBS@,$CGAL_LIBS,;t t
15081   s,@DOXYGEN@,$DOXYGEN,;t t
15082   s,@DOT@,$DOT,;t t
15083   s,@DOC@,$DOC,;t t
# Line 8703 | Line 15089 | s,@SUBDIRS@,$SUBDIRS,;t t
15089   s,@OOPSE@,$OOPSE,;t t
15090   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
15091   s,@SUBDIRS@,$SUBDIRS,;t t
8706 s,@FFLAGS@,$FFLAGS,;t t
15092   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
15093   CEOF
15094  
# Line 8734 | Line 15119 | _ACEOF
15119        (echo ':t
15120    /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
15121        if test -z "$ac_sed_cmds"; then
15122 <        ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
15122 >        ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
15123        else
15124 <        ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
15124 >        ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
15125        fi
15126        ac_sed_frag=`expr $ac_sed_frag + 1`
15127        ac_beg=$ac_end
# Line 8754 | Line 15139 | for ac_file in : $CONFIG_FILES; do test "x$ac_file" =
15139    # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
15140    case $ac_file in
15141    - | *:- | *:-:* ) # input from stdin
15142 <        cat >$tmp/stdin
15143 <        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15144 <        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15142 >        cat >$tmp/stdin
15143 >        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15144 >        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15145    *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15146 <        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15146 >        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15147    * )   ac_file_in=$ac_file.in ;;
15148    esac
15149  
15150    # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
15151    ac_dir=`(dirname "$ac_file") 2>/dev/null ||
15152   $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15153 <         X"$ac_file" : 'X\(//\)[^/]' \| \
15154 <         X"$ac_file" : 'X\(//\)$' \| \
15155 <         X"$ac_file" : 'X\(/\)' \| \
15156 <         .     : '\(.\)' 2>/dev/null ||
15153 >         X"$ac_file" : 'X\(//\)[^/]' \| \
15154 >         X"$ac_file" : 'X\(//\)$' \| \
15155 >         X"$ac_file" : 'X\(/\)' \| \
15156 >         .     : '\(.\)' 2>/dev/null ||
15157   echo X"$ac_file" |
15158      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15159            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 8784 | Line 15169 | $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
15169        as_dirs="$as_dir $as_dirs"
15170        as_dir=`(dirname "$as_dir") 2>/dev/null ||
15171   $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15172 <         X"$as_dir" : 'X\(//\)[^/]' \| \
15173 <         X"$as_dir" : 'X\(//\)$' \| \
15174 <         X"$as_dir" : 'X\(/\)' \| \
15175 <         .     : '\(.\)' 2>/dev/null ||
15172 >         X"$as_dir" : 'X\(//\)[^/]' \| \
15173 >         X"$as_dir" : 'X\(//\)$' \| \
15174 >         X"$as_dir" : 'X\(/\)' \| \
15175 >         .     : '\(.\)' 2>/dev/null ||
15176   echo X"$as_dir" |
15177      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15178            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 8825 | Line 15210 | esac
15210      ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
15211      ac_top_srcdir=$ac_top_builddir$srcdir ;;
15212   esac
8828 # Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be
8829 # absolute.
8830 ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`
8831 ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd`
8832 ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`
8833 ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`
15213  
15214 + # Do not use `cd foo && pwd` to compute absolute paths, because
15215 + # the directories may not exist.
15216 + case `pwd` in
15217 + .) ac_abs_builddir="$ac_dir";;
15218 + *)
15219 +  case "$ac_dir" in
15220 +  .) ac_abs_builddir=`pwd`;;
15221 +  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
15222 +  *) ac_abs_builddir=`pwd`/"$ac_dir";;
15223 +  esac;;
15224 + esac
15225 + case $ac_abs_builddir in
15226 + .) ac_abs_top_builddir=${ac_top_builddir}.;;
15227 + *)
15228 +  case ${ac_top_builddir}. in
15229 +  .) ac_abs_top_builddir=$ac_abs_builddir;;
15230 +  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
15231 +  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
15232 +  esac;;
15233 + esac
15234 + case $ac_abs_builddir in
15235 + .) ac_abs_srcdir=$ac_srcdir;;
15236 + *)
15237 +  case $ac_srcdir in
15238 +  .) ac_abs_srcdir=$ac_abs_builddir;;
15239 +  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
15240 +  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
15241 +  esac;;
15242 + esac
15243 + case $ac_abs_builddir in
15244 + .) ac_abs_top_srcdir=$ac_top_srcdir;;
15245 + *)
15246 +  case $ac_top_srcdir in
15247 +  .) ac_abs_top_srcdir=$ac_abs_builddir;;
15248 +  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
15249 +  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
15250 +  esac;;
15251 + esac
15252  
15253 +
15254    case $INSTALL in
15255    [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
15256    *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
# Line 8852 | Line 15270 | echo "$as_me: creating $ac_file" >&6;}
15270      configure_input="$ac_file.  "
15271    fi
15272    configure_input=$configure_input"Generated from `echo $ac_file_in |
15273 <                                     sed 's,.*/,,'` by configure."
15273 >                                     sed 's,.*/,,'` by configure."
15274  
15275    # First look for the input files in the build tree, otherwise in the
15276    # src tree.
# Line 8861 | Line 15279 | echo "$as_me: creating $ac_file" >&6;}
15279        case $f in
15280        -) echo $tmp/stdin ;;
15281        [\\/$]*)
15282 <         # Absolute (can't be DOS-style, as IFS=:)
15283 <         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15282 >         # Absolute (can't be DOS-style, as IFS=:)
15283 >         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15284   echo "$as_me: error: cannot find input file: $f" >&2;}
15285     { (exit 1); exit 1; }; }
15286 <         echo $f;;
15286 >         echo "$f";;
15287        *) # Relative
15288 <         if test -f "$f"; then
15289 <           # Build tree
15290 <           echo $f
15291 <         elif test -f "$srcdir/$f"; then
15292 <           # Source tree
15293 <           echo $srcdir/$f
15294 <         else
15295 <           # /dev/null tree
15296 <           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15288 >         if test -f "$f"; then
15289 >           # Build tree
15290 >           echo "$f"
15291 >         elif test -f "$srcdir/$f"; then
15292 >           # Source tree
15293 >           echo "$srcdir/$f"
15294 >         else
15295 >           # /dev/null tree
15296 >           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15297   echo "$as_me: error: cannot find input file: $f" >&2;}
15298     { (exit 1); exit 1; }; }
15299 <         fi;;
15299 >         fi;;
15300        esac
15301      done` || { (exit 1); exit 1; }
15302   _ACEOF
# Line 8908 | Line 15326 | s,@INSTALL@,$ac_INSTALL,;t t
15326      rm -f $tmp/out
15327    fi
15328  
15329 +  # Run the commands associated with the file.
15330 +  case $ac_file in
15331 +    make/Makefile ) chmod 0755 scripts/* ;;
15332 +    src/utils/Makefile ) chmod 0755 scripts/* ;;
15333 +    src/applications/nanoRodBuilder/Makefile ) chmod 0755 scripts/* ;;
15334 +    scripts/filepp ) chmod 0755 scripts/* ;;
15335 +  esac
15336   done
15337   _ACEOF
15338   cat >>$CONFIG_STATUS <<\_ACEOF
# Line 8920 | Line 15345 | cat >>$CONFIG_STATUS <<\_ACEOF
15345   # NAME is the cpp macro being defined and VALUE is the value it is being given.
15346   #
15347   # ac_d sets the value in "#define NAME VALUE" lines.
15348 < ac_dA='s,^\([   ]*\)#\([        ]*define[       ][      ]*\)'
15349 < ac_dB='[        ].*$,\1#\2'
15348 > ac_dA='s,^\([    ]*\)#\([        ]*define[       ][      ]*\)'
15349 > ac_dB='[         ].*$,\1#\2'
15350   ac_dC=' '
15351   ac_dD=',;t'
15352   # ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
15353 < ac_uA='s,^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
15353 > ac_uA='s,^\([    ]*\)#\([        ]*\)undef\([    ][      ]*\)'
15354   ac_uB='$,\1#\2define\3'
15355   ac_uC=' '
15356   ac_uD=',;t'
# Line 8934 | Line 15359 | for ac_file in : $CONFIG_HEADERS; do test "x$ac_file"
15359    # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
15360    case $ac_file in
15361    - | *:- | *:-:* ) # input from stdin
15362 <        cat >$tmp/stdin
15363 <        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15364 <        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15362 >        cat >$tmp/stdin
15363 >        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15364 >        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15365    *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15366 <        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15366 >        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15367    * )   ac_file_in=$ac_file.in ;;
15368    esac
15369  
# Line 8952 | Line 15377 | echo "$as_me: creating $ac_file" >&6;}
15377        case $f in
15378        -) echo $tmp/stdin ;;
15379        [\\/$]*)
15380 <         # Absolute (can't be DOS-style, as IFS=:)
15381 <         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15380 >         # Absolute (can't be DOS-style, as IFS=:)
15381 >         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15382   echo "$as_me: error: cannot find input file: $f" >&2;}
15383     { (exit 1); exit 1; }; }
15384 <         echo $f;;
15384 >         # Do quote $f, to prevent DOS paths from being IFS'd.
15385 >         echo "$f";;
15386        *) # Relative
15387 <         if test -f "$f"; then
15388 <           # Build tree
15389 <           echo $f
15390 <         elif test -f "$srcdir/$f"; then
15391 <           # Source tree
15392 <           echo $srcdir/$f
15393 <         else
15394 <           # /dev/null tree
15395 <           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15387 >         if test -f "$f"; then
15388 >           # Build tree
15389 >           echo "$f"
15390 >         elif test -f "$srcdir/$f"; then
15391 >           # Source tree
15392 >           echo "$srcdir/$f"
15393 >         else
15394 >           # /dev/null tree
15395 >           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15396   echo "$as_me: error: cannot find input file: $f" >&2;}
15397     { (exit 1); exit 1; }; }
15398 <         fi;;
15398 >         fi;;
15399        esac
15400      done` || { (exit 1); exit 1; }
15401    # Remove the trailing spaces.
15402 <  sed 's/[      ]*$//' $ac_file_inputs >$tmp/in
15402 >  sed 's/[       ]*$//' $ac_file_inputs >$tmp/in
15403  
15404   _ACEOF
15405  
# Line 8996 | Line 15422 | t clear
15422   s,[\\$`],\\&,g
15423   t clear
15424   : clear
15425 < s,^[    ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
15425 > s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
15426   t end
15427 < s,^[    ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
15427 > s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
15428   : end
15429   _ACEOF
15430   # If some macros were called several times there might be several times
# Line 9012 | Line 15438 | cat >>conftest.undefs <<\_ACEOF
15438   # example, in the case of _POSIX_SOURCE, which is predefined and required
15439   # on some systems where configure will not decide to define it.
15440   cat >>conftest.undefs <<\_ACEOF
15441 < s,^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
15441 > s,^[     ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
15442   _ACEOF
15443  
15444   # Break up conftest.defines because some shells have a limit on the size
15445   # of here documents, and old seds have small limits too (100 cmds).
15446   echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
15447 < echo '  if grep "^[     ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
15447 > echo '  if grep "^[      ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
15448   echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
15449   echo '  :' >>$CONFIG_STATUS
15450   rm -f conftest.tail
# Line 9027 | Line 15453 | do
15453    # Write a limited-size here document to $tmp/defines.sed.
15454    echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
15455    # Speed up: don't consider the non `#define' lines.
15456 <  echo '/^[     ]*#[    ]*define/!b' >>$CONFIG_STATUS
15456 >  echo '/^[      ]*#[    ]*define/!b' >>$CONFIG_STATUS
15457    # Work around the forget-to-reset-the-flag bug.
15458    echo 't clr' >>$CONFIG_STATUS
15459    echo ': clr' >>$CONFIG_STATUS
# Line 9054 | Line 15480 | do
15480    # Write a limited-size here document to $tmp/undefs.sed.
15481    echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
15482    # Speed up: don't consider the non `#undef'
15483 <  echo '/^[     ]*#[    ]*undef/!b' >>$CONFIG_STATUS
15483 >  echo '/^[      ]*#[    ]*undef/!b' >>$CONFIG_STATUS
15484    # Work around the forget-to-reset-the-flag bug.
15485    echo 't clr' >>$CONFIG_STATUS
15486    echo ': clr' >>$CONFIG_STATUS
# Line 9088 | Line 15514 | $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
15514      else
15515        ac_dir=`(dirname "$ac_file") 2>/dev/null ||
15516   $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15517 <         X"$ac_file" : 'X\(//\)[^/]' \| \
15518 <         X"$ac_file" : 'X\(//\)$' \| \
15519 <         X"$ac_file" : 'X\(/\)' \| \
15520 <         .     : '\(.\)' 2>/dev/null ||
15517 >         X"$ac_file" : 'X\(//\)[^/]' \| \
15518 >         X"$ac_file" : 'X\(//\)$' \| \
15519 >         X"$ac_file" : 'X\(/\)' \| \
15520 >         .     : '\(.\)' 2>/dev/null ||
15521   echo X"$ac_file" |
15522      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15523            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 9107 | Line 15533 | $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
15533        as_dirs="$as_dir $as_dirs"
15534        as_dir=`(dirname "$as_dir") 2>/dev/null ||
15535   $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15536 <         X"$as_dir" : 'X\(//\)[^/]' \| \
15537 <         X"$as_dir" : 'X\(//\)$' \| \
15538 <         X"$as_dir" : 'X\(/\)' \| \
15539 <         .     : '\(.\)' 2>/dev/null ||
15536 >         X"$as_dir" : 'X\(//\)[^/]' \| \
15537 >         X"$as_dir" : 'X\(//\)$' \| \
15538 >         X"$as_dir" : 'X\(/\)' \| \
15539 >         .     : '\(.\)' 2>/dev/null ||
15540   echo X"$as_dir" |
15541      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15542            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 9155 | Line 15581 | $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
15581    # Make relative symlinks.
15582    ac_dest_dir=`(dirname "$ac_dest") 2>/dev/null ||
15583   $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15584 <         X"$ac_dest" : 'X\(//\)[^/]' \| \
15585 <         X"$ac_dest" : 'X\(//\)$' \| \
15586 <         X"$ac_dest" : 'X\(/\)' \| \
15587 <         .     : '\(.\)' 2>/dev/null ||
15584 >         X"$ac_dest" : 'X\(//\)[^/]' \| \
15585 >         X"$ac_dest" : 'X\(//\)$' \| \
15586 >         X"$ac_dest" : 'X\(/\)' \| \
15587 >         .     : '\(.\)' 2>/dev/null ||
15588   echo X"$ac_dest" |
15589      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15590            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 9174 | Line 15600 | $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
15600        as_dirs="$as_dir $as_dirs"
15601        as_dir=`(dirname "$as_dir") 2>/dev/null ||
15602   $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15603 <         X"$as_dir" : 'X\(//\)[^/]' \| \
15604 <         X"$as_dir" : 'X\(//\)$' \| \
15605 <         X"$as_dir" : 'X\(/\)' \| \
15606 <         .     : '\(.\)' 2>/dev/null ||
15603 >         X"$as_dir" : 'X\(//\)[^/]' \| \
15604 >         X"$as_dir" : 'X\(//\)$' \| \
15605 >         X"$as_dir" : 'X\(/\)' \| \
15606 >         .     : '\(.\)' 2>/dev/null ||
15607   echo X"$as_dir" |
15608      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15609            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 9215 | Line 15641 | esac
15641      ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
15642      ac_top_srcdir=$ac_top_builddir$srcdir ;;
15643   esac
9218 # Don't blindly perform a `cd "$ac_dest_dir"/$ac_foo && pwd` since $ac_foo can be
9219 # absolute.
9220 ac_abs_builddir=`cd "$ac_dest_dir" && cd $ac_builddir && pwd`
9221 ac_abs_top_builddir=`cd "$ac_dest_dir" && cd ${ac_top_builddir}. && pwd`
9222 ac_abs_srcdir=`cd "$ac_dest_dir" && cd $ac_srcdir && pwd`
9223 ac_abs_top_srcdir=`cd "$ac_dest_dir" && cd $ac_top_srcdir && pwd`
15644  
15645 + # Do not use `cd foo && pwd` to compute absolute paths, because
15646 + # the directories may not exist.
15647 + case `pwd` in
15648 + .) ac_abs_builddir="$ac_dest_dir";;
15649 + *)
15650 +  case "$ac_dest_dir" in
15651 +  .) ac_abs_builddir=`pwd`;;
15652 +  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dest_dir";;
15653 +  *) ac_abs_builddir=`pwd`/"$ac_dest_dir";;
15654 +  esac;;
15655 + esac
15656 + case $ac_abs_builddir in
15657 + .) ac_abs_top_builddir=${ac_top_builddir}.;;
15658 + *)
15659 +  case ${ac_top_builddir}. in
15660 +  .) ac_abs_top_builddir=$ac_abs_builddir;;
15661 +  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
15662 +  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
15663 +  esac;;
15664 + esac
15665 + case $ac_abs_builddir in
15666 + .) ac_abs_srcdir=$ac_srcdir;;
15667 + *)
15668 +  case $ac_srcdir in
15669 +  .) ac_abs_srcdir=$ac_abs_builddir;;
15670 +  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
15671 +  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
15672 +  esac;;
15673 + esac
15674 + case $ac_abs_builddir in
15675 + .) ac_abs_top_srcdir=$ac_top_srcdir;;
15676 + *)
15677 +  case $ac_top_srcdir in
15678 +  .) ac_abs_top_srcdir=$ac_abs_builddir;;
15679 +  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
15680 +  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
15681 +  esac;;
15682 + esac
15683  
15684 +
15685    case $srcdir in
15686    [\\/$]* | ?:[\\/]* ) ac_rel_source=$srcdir/$ac_source ;;
15687        *) ac_rel_source=$ac_top_builddir$srcdir/$ac_source ;;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines