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 961 by gezelter, Wed May 17 16:10:16 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 ZLIB_INC_DIR ZLIB_LIB_DIR ZLIB FFTW_INC_DIR FFTW_LIB_DIR FFTW_LIBS 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
755 ac_env_CC_set=${CC+set}
756 ac_env_CC_value=$CC
757 ac_cv_env_CC_set=${CC+set}
758 ac_cv_env_CC_value=$CC
759 ac_env_CFLAGS_set=${CFLAGS+set}
760 ac_env_CFLAGS_value=$CFLAGS
761 ac_cv_env_CFLAGS_set=${CFLAGS+set}
762 ac_cv_env_CFLAGS_value=$CFLAGS
763 ac_env_LDFLAGS_set=${LDFLAGS+set}
764 ac_env_LDFLAGS_value=$LDFLAGS
765 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
766 ac_cv_env_LDFLAGS_value=$LDFLAGS
767 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
768 ac_env_CPPFLAGS_value=$CPPFLAGS
769 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
770 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
756   ac_env_CXX_set=${CXX+set}
757   ac_env_CXX_value=$CXX
758   ac_cv_env_CXX_set=${CXX+set}
# Line 776 | Line 761 | ac_cv_env_CXXFLAGS_value=$CXXFLAGS
761   ac_env_CXXFLAGS_value=$CXXFLAGS
762   ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763   ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764 < ac_env_F90_set=${F90+set}
765 < ac_env_F90_value=$F90
766 < ac_cv_env_F90_set=${F90+set}
767 < ac_cv_env_F90_value=$F90
768 < ac_env_F90FLAGS_set=${F90FLAGS+set}
769 < ac_env_F90FLAGS_value=$F90FLAGS
770 < ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
771 < ac_cv_env_F90FLAGS_value=$F90FLAGS
764 > ac_env_LDFLAGS_set=${LDFLAGS+set}
765 > ac_env_LDFLAGS_value=$LDFLAGS
766 > ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 > ac_cv_env_LDFLAGS_value=$LDFLAGS
768 > ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 > ac_env_CPPFLAGS_value=$CPPFLAGS
770 > ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 > ac_cv_env_CPPFLAGS_value=$CPPFLAGS
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-single         compile OOPSE in single precision
875 +  --enable-float          synonym for --enable-single
876    --enable-doxygen        enable documentation generation with doxygen (auto)
877    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
878    --enable-html-docs      enable HTML generation with doxygen (yes)
879    --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
872  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
880  
881   Optional Packages:
882    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
883    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
884 +  --with-perl-shebang     override what perl thinks is the way for the kernel
885 +                          to start it (seldom needed)
886 +  --with-zlib=DIR         root directory path of zlib installation (defaults
887 +                          to /usr/local or /usr if not found in /usr/local)
888 +  --with-fftw=DIR         root directory path of fftw installation (defaults
889 +                          to /usr/local or /usr if not found in /usr/local)
890    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
891 <  --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
891 >  --with-cgal-makefile=FILE  CGAL makefile that should be used
892  
893   Some influential environment variables:
894 <  CC          C compiler command
895 <  CFLAGS      C compiler flags
894 >  CXX         C++ compiler command
895 >  CXXFLAGS    C++ compiler flags
896    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
897                nonstandard directory <lib dir>
898    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
899                headers in a nonstandard directory <include dir>
900 <  CXX         C++ compiler command
901 <  CXXFLAGS    C++ compiler flags
902 <  F90         Fortran 90 compiler command
903 <  F90FLAGS    Fortran 90 compiler flags
900 >  CC          C compiler command
901 >  CFLAGS      C compiler flags
902 >  FC          Fortran compiler command
903 >  FCFLAGS     Fortran compiler flags
904    CPP         C preprocessor
905 +  CXXCPP      C++ preprocessor
906  
907   Use these variables to override the choices made by `configure' or to help
908   it to find libraries and programs with nonstandard names/locations.
# Line 929 | Line 941 | esac
941      ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
942      ac_top_srcdir=$ac_top_builddir$srcdir ;;
943   esac
944 < # Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be
945 < # absolute.
946 < ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`
947 < ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd`
948 < ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`
949 < ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`
944 >
945 > # Do not use `cd foo && pwd` to compute absolute paths, because
946 > # the directories may not exist.
947 > case `pwd` in
948 > .) ac_abs_builddir="$ac_dir";;
949 > *)
950 >  case "$ac_dir" in
951 >  .) ac_abs_builddir=`pwd`;;
952 >  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
953 >  *) ac_abs_builddir=`pwd`/"$ac_dir";;
954 >  esac;;
955 > esac
956 > case $ac_abs_builddir in
957 > .) ac_abs_top_builddir=${ac_top_builddir}.;;
958 > *)
959 >  case ${ac_top_builddir}. in
960 >  .) ac_abs_top_builddir=$ac_abs_builddir;;
961 >  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
962 >  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
963 >  esac;;
964 > esac
965 > case $ac_abs_builddir in
966 > .) ac_abs_srcdir=$ac_srcdir;;
967 > *)
968 >  case $ac_srcdir in
969 >  .) ac_abs_srcdir=$ac_abs_builddir;;
970 >  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
971 >  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
972 >  esac;;
973 > esac
974 > case $ac_abs_builddir in
975 > .) ac_abs_top_srcdir=$ac_top_srcdir;;
976 > *)
977 >  case $ac_top_srcdir in
978 >  .) ac_abs_top_srcdir=$ac_abs_builddir;;
979 >  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
980 >  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
981 >  esac;;
982 > esac
983  
984      cd $ac_dir
985      # Check for guested configure; otherwise get Cygnus style configure.
# Line 945 | Line 990 | ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir &
990        echo
991        $SHELL $ac_srcdir/configure  --help=recursive
992      elif test -f $ac_srcdir/configure.ac ||
993 <           test -f $ac_srcdir/configure.in; then
993 >           test -f $ac_srcdir/configure.in; then
994        echo
995        $ac_configure --help
996      else
# Line 958 | Line 1003 | if $ac_init_version; then
1003   test -n "$ac_init_help" && exit 0
1004   if $ac_init_version; then
1005    cat <<\_ACEOF
1006 < OOPSE configure 2.0
1007 < generated by GNU Autoconf 2.57
1006 > OOPSE configure 3.0
1007 > generated by GNU Autoconf 2.59
1008  
1009 < Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
965 < Free Software Foundation, Inc.
1009 > Copyright (C) 2003 Free Software Foundation, Inc.
1010   This configure script is free software; the Free Software Foundation
1011   gives unlimited permission to copy, distribute and modify it.
1012   _ACEOF
# Line 973 | Line 1017 | running configure, to aid debugging if configure makes
1017   This file contains any messages produced by compilers while
1018   running configure, to aid debugging if configure makes a mistake.
1019  
1020 < It was created by OOPSE $as_me 2.0, which was
1021 < generated by GNU Autoconf 2.57.  Invocation command line was
1020 > It was created by OOPSE $as_me 3.0, which was
1021 > generated by GNU Autoconf 2.59.  Invocation command line was
1022  
1023    $ $0 $@
1024  
# Line 1051 | Line 1095 | do
1095      2)
1096        ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1097        if test $ac_must_keep_next = true; then
1098 <        ac_must_keep_next=false # Got value, back to normal.
1098 >        ac_must_keep_next=false # Got value, back to normal.
1099        else
1100 <        case $ac_arg in
1101 <          *=* | --config-cache | -C | -disable-* | --disable-* \
1102 <          | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1103 <          | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1104 <          | -with-* | --with-* | -without-* | --without-* | --x)
1105 <            case "$ac_configure_args0 " in
1106 <              "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1107 <            esac
1108 <            ;;
1109 <          -* ) ac_must_keep_next=true ;;
1110 <        esac
1100 >        case $ac_arg in
1101 >          *=* | --config-cache | -C | -disable-* | --disable-* \
1102 >          | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1103 >          | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1104 >          | -with-* | --with-* | -without-* | --without-* | --x)
1105 >            case "$ac_configure_args0 " in
1106 >              "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1107 >            esac
1108 >            ;;
1109 >          -* ) ac_must_keep_next=true ;;
1110 >        esac
1111        fi
1112        ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1113        # Get rid of the leading space.
# Line 1097 | Line 1141 | _ASBOX
1141      case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1142      *ac_space=\ *)
1143        sed -n \
1144 <        "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1145 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1144 >        "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1145 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1146        ;;
1147      *)
1148        sed -n \
1149 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1149 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1150        ;;
1151      esac;
1152   }
# Line 1131 | Line 1175 | _ASBOX
1175        for ac_var in $ac_subst_files
1176        do
1177          eval ac_val=$`echo $ac_var`
1178 <        echo "$ac_var='"'"'$ac_val'"'"'"
1178 >        echo "$ac_var='"'"'$ac_val'"'"'"
1179        done | sort
1180        echo
1181      fi
# Line 1150 | Line 1194 | _ASBOX
1194        echo "$as_me: caught signal $ac_signal"
1195      echo "$as_me: exit $exit_status"
1196    } >&5
1197 <  rm -f core core.* *.core &&
1197 >  rm -f core *.core &&
1198    rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1199      exit $exit_status
1200       ' 0
# Line 1230 | Line 1274 | for ac_var in `(set) 2>&1 |
1274   # value.
1275   ac_cache_corrupted=false
1276   for ac_var in `(set) 2>&1 |
1277 <               sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1277 >               sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1278    eval ac_old_set=\$ac_cv_env_${ac_var}_set
1279    eval ac_new_set=\$ac_env_${ac_var}_set
1280    eval ac_old_val="\$ac_cv_env_${ac_var}_value"
# Line 1247 | Line 1291 | echo "$as_me: error: \`$ac_var' was not set in the pre
1291      ,);;
1292      *)
1293        if test "x$ac_old_val" != "x$ac_new_val"; then
1294 <        { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1294 >        { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1295   echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1296 <        { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1296 >        { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1297   echo "$as_me:   former value:  $ac_old_val" >&2;}
1298 <        { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1298 >        { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1299   echo "$as_me:   current value: $ac_new_val" >&2;}
1300 <        ac_cache_corrupted=:
1300 >        ac_cache_corrupted=:
1301        fi;;
1302    esac
1303    # Pass precious variables to config.status.
# Line 1335 | Line 1379 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1379   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1380  
1381  
1382 < # 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).
1382 >          ac_config_headers="$ac_config_headers src/config.h"
1383  
1384  
1389 # 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
1385  
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
1386  
1387  
1388  
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
1389  
1390  
1391  
1458 ## ----------------------- ##
1459 ## 1. Language selection.  ##
1460 ## ----------------------- ##
1392  
1462 # ----------------------------- #
1463 # 1b. The Fortran 90 language.  #
1464 # ----------------------------- #
1393  
1466 # AC_LANG(Fortran 90)
1467 # -------------------
1394  
1395  
1396  
1471 # _AC_LANG_ABBREV(Fortran 90)
1472 # ---------------------------
1397  
1398  
1399  
1476 # ----------------------------- #
1477 # 1c. The Fortran 95 language.  #
1478 # ----------------------------- #
1400  
1480 # AC_LANG(Fortran 95)
1481 # -------------------
1401  
1402  
1403  
1485 # _AC_LANG_ABBREV(Fortran 95)
1486 # ---------------------------
1404  
1405  
1406  
1490 ## ---------------------- ##
1491 ## 2.Producing programs.  ##
1492 ## ---------------------- ##
1407  
1494 # ------------------------ #
1495 # 2b. Fortran 90 sources.  #
1496 # ------------------------ #
1408  
1498 # AC_LANG_SOURCE(Fortran 90)(BODY)
1499 # --------------------------------
1409  
1410  
1411  
1503 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1504 # -----------------------------------------------
1412  
1413  
1507 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1508 # --------------------------------------------
1414  
1415  
1416  
1512 # ------------------------ #
1513 # 2c. Fortran 95 sources.  #
1514 # ------------------------ #
1417  
1516 # AC_LANG_SOURCE(Fortran 95)(BODY)
1517 # --------------------------------
1418  
1419  
1520 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1521 # -----------------------------------------------
1420  
1421  
1524 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1525 # --------------------------------------------
1422  
1423  
1424  
1529 ## -------------------------------------------- ##
1530 ## 3. Looking for Compilers and Preprocessors.  ##
1531 ## -------------------------------------------- ##
1425  
1533 # ----------------------------- #
1534 # 3b. The Fortran 90 compiler.  #
1535 # ----------------------------- #
1426  
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.
1427   #
1556 # Compilers are ordered by
1557 #  1. F90, F95
1558 #  2. Good/tested native compilers, bad/untested native compilers
1428   #
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.
1429   #
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
1430  
1431  
1600 ## ------------------------------- ##
1601 ## 4. Compilers' characteristics.  ##
1602 ## ------------------------------- ##
1432  
1433  
1605 # ---------------------------------------- #
1606 # 4b. Fortan 90 compiler characteristics.  #
1607 # ---------------------------------------- #
1434  
1435  
1436 < # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1437 < # -------------------------------------------------
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 < # --------------
1436 > # AC_F90_MODULE_NAMES
1437 > # -------------------
1438   #
1439 < # 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 < # ----------------------
1439 > # Figure out how the Fortran 90 compiler constructs module file names
1440   #
1441 < # 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
1441 > # AC_F90_MODULE_NAMES
1442  
1443  
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
1444  
1676 # The replacement is empty.
1445  
1446  
1447  
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
1448  
1449  
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
1450  
1451  
1697 # ---------------------------------------- #
1698 # 4c. Fortan 95 compiler characteristics.  #
1699 # ---------------------------------------- #
1452  
1453  
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
1454  
1455  
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
1456  
1457  
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
1458  
1459  
1751 # _AC_F95_NAME_MANGLING
1752 # ---------------------
1753 # Test for the name mangling scheme used by the Fortran 95 compiler.
1754 #
1755 # Sets ac_cv_f95_mangling. The value contains three fields, separated
1756 # by commas:
1757 #
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
1765 #
1766 # _AC_F95_NAME_MANGLING
1460  
1768 # The replacement is empty.
1461  
1462  
1463  
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
1464  
1465  
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
1466  
1788 # AC_F90_MODULE_NAMES
1789 # -------------------
1790 #
1791 # Figure out how the Fortran 90 compiler constructs module file names
1792 #
1793 # AC_F90_MODULE_NAMES
1467  
1468  
1469  
# Line 1850 | Line 1523 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1523  
1524  
1525  
1853 # set program name
1854 PROGNAME="oopse"
1526  
1527  
1857 # there are two ways to do debugging.  One with the --enable-debug flag
1858 # and one using the DEBUG environment variable
1528  
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
1529  
1868 cat >>confdefs.h <<\_ACEOF
1869 #define debug 1
1870 _ACEOF
1871
1872  msg="$msg, debug mode"
1873 fi
1874
1875
1530   # who am i
1531   # Make sure we can run config.sub.
1532   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 1931 | Line 1585 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1585  
1586  
1587  
1588 < ac_ext=c
1589 < ac_cpp='$CPP $CPPFLAGS'
1590 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1591 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1592 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1588 > # set program name
1589 > PROGNAME="oopse"
1590 >
1591 >
1592 >
1593 >
1594 > OBJEXT=".$OBJEXT"
1595 >
1596 > OOPSE=oopse
1597 >
1598 > if test "x${prefix}" = "xNONE"
1599 > then
1600 >  OOPSE_HOME=${ac_default_prefix}/oopse
1601 > else
1602 >  OOPSE_HOME=${prefix}/oopse
1603 > fi
1604 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1605 > if test "${enable_oopse_home+set}" = set; then
1606 >  enableval="$enable_oopse_home"
1607 >  OOPSE_HOME="${enableval}"
1608 > fi;
1609 >
1610 > # there are two ways to do debugging.  One with the --enable-debug flag
1611 > # and one using the DEBUG environment variable
1612 >
1613 > debug=0
1614 > # Check whether --enable-debug or --disable-debug was given.
1615 > if test "${enable_debug+set}" = set; then
1616 >  enableval="$enable_debug"
1617 >  debug=1
1618 > fi;
1619 > if test "${DEBUG}"; then
1620 >
1621 > cat >>confdefs.h <<\_ACEOF
1622 > #define debug 1
1623 > _ACEOF
1624 >
1625 >  msg="$msg, debug mode"
1626 > fi
1627 >
1628 >
1629 > # Check whether --enable-single or --disable-single was given.
1630 > if test "${enable_single+set}" = set; then
1631 >  enableval="$enable_single"
1632 >  ok=$enableval
1633 > else
1634 >  ok=no
1635 > fi;
1636 > # Check whether --enable-float or --disable-float was given.
1637 > if test "${enable_float+set}" = set; then
1638 >  enableval="$enable_float"
1639 >  ok=$enableval
1640 > fi;
1641 > if test "$ok" = "yes"; then
1642 >
1643 > cat >>confdefs.h <<\_ACEOF
1644 > #define SINGLE_PRECISION 1
1645 > _ACEOF
1646 >
1647 >        PRECISION=s
1648 > else
1649 >        PRECISION=d
1650 > fi
1651 >
1652 > # Checks for programs.
1653 > ac_ext=cc
1654 > ac_cpp='$CXXCPP $CPPFLAGS'
1655 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1656 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1657 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1658   if test -n "$ac_tool_prefix"; then
1659 <  for ac_prog in icc xlc gcc cc
1659 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1660    do
1661      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1662   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1663   echo "$as_me:$LINENO: checking for $ac_word" >&5
1664   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1665 < if test "${ac_cv_prog_CC+set}" = set; then
1665 > if test "${ac_cv_prog_CXX+set}" = set; then
1666    echo $ECHO_N "(cached) $ECHO_C" >&6
1667   else
1668 <  if test -n "$CC"; then
1669 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1668 >  if test -n "$CXX"; then
1669 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1670   else
1671   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1672   for as_dir in $PATH
# Line 1956 | Line 1675 | do
1675    test -z "$as_dir" && as_dir=.
1676    for ac_exec_ext in '' $ac_executable_extensions; do
1677    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1678 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1678 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1679      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1680      break 2
1681    fi
# Line 1965 | Line 1684 | fi
1684  
1685   fi
1686   fi
1687 < CC=$ac_cv_prog_CC
1688 < if test -n "$CC"; then
1689 <  echo "$as_me:$LINENO: result: $CC" >&5
1690 < echo "${ECHO_T}$CC" >&6
1687 > CXX=$ac_cv_prog_CXX
1688 > if test -n "$CXX"; then
1689 >  echo "$as_me:$LINENO: result: $CXX" >&5
1690 > echo "${ECHO_T}$CXX" >&6
1691   else
1692    echo "$as_me:$LINENO: result: no" >&5
1693   echo "${ECHO_T}no" >&6
1694   fi
1695  
1696 <    test -n "$CC" && break
1696 >    test -n "$CXX" && break
1697    done
1698   fi
1699 < if test -z "$CC"; then
1700 <  ac_ct_CC=$CC
1701 <  for ac_prog in icc xlc gcc cc
1699 > if test -z "$CXX"; then
1700 >  ac_ct_CXX=$CXX
1701 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1702   do
1703    # Extract the first word of "$ac_prog", so it can be a program name with args.
1704   set dummy $ac_prog; ac_word=$2
1705   echo "$as_me:$LINENO: checking for $ac_word" >&5
1706   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1707 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1707 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1708    echo $ECHO_N "(cached) $ECHO_C" >&6
1709   else
1710 <  if test -n "$ac_ct_CC"; then
1711 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1710 >  if test -n "$ac_ct_CXX"; then
1711 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1712   else
1713   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1714   for as_dir in $PATH
# Line 1998 | Line 1717 | do
1717    test -z "$as_dir" && as_dir=.
1718    for ac_exec_ext in '' $ac_executable_extensions; do
1719    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1720 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1720 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1721      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1722      break 2
1723    fi
# Line 2007 | Line 1726 | fi
1726  
1727   fi
1728   fi
1729 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1730 < if test -n "$ac_ct_CC"; then
1731 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1732 < echo "${ECHO_T}$ac_ct_CC" >&6
1729 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1730 > if test -n "$ac_ct_CXX"; then
1731 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1732 > echo "${ECHO_T}$ac_ct_CXX" >&6
1733   else
1734    echo "$as_me:$LINENO: result: no" >&5
1735   echo "${ECHO_T}no" >&6
1736   fi
1737  
1738 <  test -n "$ac_ct_CC" && break
1738 >  test -n "$ac_ct_CXX" && break
1739   done
1740 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1741  
1742 <  CC=$ac_ct_CC
1742 >  CXX=$ac_ct_CXX
1743   fi
1744  
1745  
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
1746   # Provide some information about the compiler.
1747   echo "$as_me:$LINENO:" \
1748 <     "checking for C compiler version" >&5
1748 >     "checking for C++ compiler version" >&5
1749   ac_compiler=`set X $ac_compile; echo $2`
1750   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1751    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2050 | Line 1764 | cat >conftest.$ac_ext <<_ACEOF
1764    (exit $ac_status); }
1765  
1766   cat >conftest.$ac_ext <<_ACEOF
2053 #line $LINENO "configure"
1767   /* confdefs.h.  */
1768   _ACEOF
1769   cat confdefs.h >>conftest.$ac_ext
# Line 2070 | Line 1783 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1783   # Try to create an executable without -o first, disregard a.out.
1784   # It will help us diagnose broken compilers, and finding out an intuition
1785   # of exeext.
1786 < echo "$as_me:$LINENO: checking for C compiler default output" >&5
1787 < echo $ECHO_N "checking for C compiler default output... $ECHO_C" >&6
1786 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1787 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1788   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1789   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1790    (eval $ac_link_default) 2>&5
# Line 2091 | Line 1804 | do
1804    test -f "$ac_file" || continue
1805    case $ac_file in
1806      *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
1807 <        ;;
1807 >        ;;
1808      conftest.$ac_ext )
1809 <        # This is the source file.
1810 <        ;;
1809 >        # This is the source file.
1810 >        ;;
1811      [ab].out )
1812 <        # We found the default executable, but exeext='' is most
1813 <        # certainly right.
1814 <        break;;
1812 >        # We found the default executable, but exeext='' is most
1813 >        # certainly right.
1814 >        break;;
1815      *.* )
1816 <        ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
1817 <        # FIXME: I believe we export ac_cv_exeext for Libtool,
1818 <        # but it would be cool to find out if it's true.  Does anybody
1819 <        # maintain Libtool? --akim.
1820 <        export ac_cv_exeext
1821 <        break;;
1816 >        ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
1817 >        # FIXME: I believe we export ac_cv_exeext for Libtool,
1818 >        # but it would be cool to find out if it's true.  Does anybody
1819 >        # maintain Libtool? --akim.
1820 >        export ac_cv_exeext
1821 >        break;;
1822      * )
1823 <        break;;
1823 >        break;;
1824    esac
1825   done
1826   else
1827    echo "$as_me: failed program was:" >&5
1828   sed 's/^/| /' conftest.$ac_ext >&5
1829  
1830 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1830 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1831   See \`config.log' for more details." >&5
1832 < echo "$as_me: error: C compiler cannot create executables
1832 > echo "$as_me: error: C++ compiler cannot create executables
1833   See \`config.log' for more details." >&2;}
1834     { (exit 77); exit 77; }; }
1835   fi
# Line 2127 | Line 1840 | echo "${ECHO_T}$ac_file" >&6
1840  
1841   # Check the compiler produces executables we can run.  If not, either
1842   # the compiler is broken, or we cross compile.
1843 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1844 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1843 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1844 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1845   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1846   # If not cross compiling, check that we can run a simple program.
1847   if test "$cross_compiling" != yes; then
# Line 2143 | Line 1856 | if test "$cross_compiling" != yes; then
1856      if test "$cross_compiling" = maybe; then
1857          cross_compiling=yes
1858      else
1859 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1859 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1860   If you meant to cross compile, use \`--host'.
1861   See \`config.log' for more details." >&5
1862 < echo "$as_me: error: cannot run C compiled programs.
1862 > echo "$as_me: error: cannot run C++ compiled programs.
1863   If you meant to cross compile, use \`--host'.
1864   See \`config.log' for more details." >&2;}
1865     { (exit 1); exit 1; }; }
# Line 2181 | Line 1894 | for ac_file in conftest.exe conftest conftest.*; do
1894    case $ac_file in
1895      *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
1896      *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
1897 <          export ac_cv_exeext
1898 <          break;;
1897 >          export ac_cv_exeext
1898 >          break;;
1899      * ) break;;
1900    esac
1901   done
# Line 2207 | Line 1920 | else
1920    echo $ECHO_N "(cached) $ECHO_C" >&6
1921   else
1922    cat >conftest.$ac_ext <<_ACEOF
2210 #line $LINENO "configure"
1923   /* confdefs.h.  */
1924   _ACEOF
1925   cat confdefs.h >>conftest.$ac_ext
# Line 2252 | Line 1964 | ac_objext=$OBJEXT
1964   echo "${ECHO_T}$ac_cv_objext" >&6
1965   OBJEXT=$ac_cv_objext
1966   ac_objext=$OBJEXT
1967 < echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
1968 < echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
1969 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
1967 > echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1968 > echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1969 > if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1970    echo $ECHO_N "(cached) $ECHO_C" >&6
1971   else
1972    cat >conftest.$ac_ext <<_ACEOF
2261 #line $LINENO "configure"
1973   /* confdefs.h.  */
1974   _ACEOF
1975   cat confdefs.h >>conftest.$ac_ext
# Line 2278 | Line 1989 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1989   _ACEOF
1990   rm -f conftest.$ac_objext
1991   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1992 <  (eval $ac_compile) 2>&5
1992 >  (eval $ac_compile) 2>conftest.er1
1993    ac_status=$?
1994 +  grep -v '^ *+' conftest.er1 >conftest.err
1995 +  rm -f conftest.er1
1996 +  cat conftest.err >&5
1997    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1998    (exit $ac_status); } &&
1999 <         { ac_try='test -s conftest.$ac_objext'
1999 >         { ac_try='test -z "$ac_cxx_werror_flag"
2000 >                         || test ! -s conftest.err'
2001    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2002    (eval $ac_try) 2>&5
2003    ac_status=$?
2004    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2005 +  (exit $ac_status); }; } &&
2006 +         { ac_try='test -s conftest.$ac_objext'
2007 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2008 +  (eval $ac_try) 2>&5
2009 +  ac_status=$?
2010 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2011    (exit $ac_status); }; }; then
2012    ac_compiler_gnu=yes
2013   else
# Line 2295 | Line 2016 | fi
2016  
2017   ac_compiler_gnu=no
2018   fi
2019 < rm -f conftest.$ac_objext conftest.$ac_ext
2020 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
2019 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2020 > ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2021  
2022   fi
2023 < echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2024 < echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2025 < GCC=`test $ac_compiler_gnu = yes && echo yes`
2026 < ac_test_CFLAGS=${CFLAGS+set}
2027 < ac_save_CFLAGS=$CFLAGS
2028 < CFLAGS="-g"
2029 < echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2030 < echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2031 < if test "${ac_cv_prog_cc_g+set}" = set; then
2023 > echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2024 > echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2025 > GXX=`test $ac_compiler_gnu = yes && echo yes`
2026 > ac_test_CXXFLAGS=${CXXFLAGS+set}
2027 > ac_save_CXXFLAGS=$CXXFLAGS
2028 > CXXFLAGS="-g"
2029 > echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2030 > echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2031 > if test "${ac_cv_prog_cxx_g+set}" = set; then
2032    echo $ECHO_N "(cached) $ECHO_C" >&6
2033   else
2034    cat >conftest.$ac_ext <<_ACEOF
2314 #line $LINENO "configure"
2035   /* confdefs.h.  */
2036   _ACEOF
2037   cat confdefs.h >>conftest.$ac_ext
# Line 2328 | Line 2048 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2048   _ACEOF
2049   rm -f conftest.$ac_objext
2050   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2051 <  (eval $ac_compile) 2>&5
2051 >  (eval $ac_compile) 2>conftest.er1
2052    ac_status=$?
2053 +  grep -v '^ *+' conftest.er1 >conftest.err
2054 +  rm -f conftest.er1
2055 +  cat conftest.err >&5
2056    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2057    (exit $ac_status); } &&
2058 <         { ac_try='test -s conftest.$ac_objext'
2058 >         { ac_try='test -z "$ac_cxx_werror_flag"
2059 >                         || test ! -s conftest.err'
2060    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2061    (eval $ac_try) 2>&5
2062    ac_status=$?
2063    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2064 +  (exit $ac_status); }; } &&
2065 +         { ac_try='test -s conftest.$ac_objext'
2066 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2067 +  (eval $ac_try) 2>&5
2068 +  ac_status=$?
2069 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2070    (exit $ac_status); }; }; then
2071 <  ac_cv_prog_cc_g=yes
2071 >  ac_cv_prog_cxx_g=yes
2072   else
2073    echo "$as_me: failed program was:" >&5
2074   sed 's/^/| /' conftest.$ac_ext >&5
2075  
2076 < ac_cv_prog_cc_g=no
2076 > ac_cv_prog_cxx_g=no
2077   fi
2078 < rm -f conftest.$ac_objext conftest.$ac_ext
2078 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2079   fi
2080 < echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2081 < echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2082 < if test "$ac_test_CFLAGS" = set; then
2083 <  CFLAGS=$ac_save_CFLAGS
2084 < elif test $ac_cv_prog_cc_g = yes; then
2085 <  if test "$GCC" = yes; then
2086 <    CFLAGS="-g -O2"
2080 > echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2081 > echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2082 > if test "$ac_test_CXXFLAGS" = set; then
2083 >  CXXFLAGS=$ac_save_CXXFLAGS
2084 > elif test $ac_cv_prog_cxx_g = yes; then
2085 >  if test "$GXX" = yes; then
2086 >    CXXFLAGS="-g -O2"
2087    else
2088 <    CFLAGS="-g"
2088 >    CXXFLAGS="-g"
2089    fi
2090   else
2091 <  if test "$GCC" = yes; then
2092 <    CFLAGS="-O2"
2091 >  if test "$GXX" = yes; then
2092 >    CXXFLAGS="-O2"
2093    else
2094 <    CFLAGS=
2094 >    CXXFLAGS=
2095    fi
2096   fi
2097 < echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2098 < echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2099 < if test "${ac_cv_prog_cc_stdc+set}" = set; then
2100 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2101 < else
2102 <  ac_cv_prog_cc_stdc=no
2103 < ac_save_CC=$CC
2104 < cat >conftest.$ac_ext <<_ACEOF
2105 < #line $LINENO "configure"
2097 > for ac_declaration in \
2098 >   '' \
2099 >   'extern "C" void std::exit (int) throw (); using std::exit;' \
2100 >   'extern "C" void std::exit (int); using std::exit;' \
2101 >   'extern "C" void exit (int) throw ();' \
2102 >   'extern "C" void exit (int);' \
2103 >   'void exit (int);'
2104 > do
2105 >  cat >conftest.$ac_ext <<_ACEOF
2106   /* confdefs.h.  */
2107   _ACEOF
2108   cat confdefs.h >>conftest.$ac_ext
2109   cat >>conftest.$ac_ext <<_ACEOF
2110   /* end confdefs.h.  */
2111 < #include <stdarg.h>
2112 < #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;
2111 > $ac_declaration
2112 > #include <stdlib.h>
2113   int
2114   main ()
2115   {
2116 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2116 > exit (42);
2117    ;
2118    return 0;
2119   }
2120   _ACEOF
2121 < # 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
2121 > rm -f conftest.$ac_objext
2122   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2123 <  (eval $ac_compile) 2>&5
2123 >  (eval $ac_compile) 2>conftest.er1
2124    ac_status=$?
2125 +  grep -v '^ *+' conftest.er1 >conftest.err
2126 +  rm -f conftest.er1
2127 +  cat conftest.err >&5
2128    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2129    (exit $ac_status); } &&
2130 <         { ac_try='test -s conftest.$ac_objext'
2130 >         { ac_try='test -z "$ac_cxx_werror_flag"
2131 >                         || test ! -s conftest.err'
2132    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2133    (eval $ac_try) 2>&5
2134    ac_status=$?
2135    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2136 +  (exit $ac_status); }; } &&
2137 +         { ac_try='test -s conftest.$ac_objext'
2138 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2139 +  (eval $ac_try) 2>&5
2140 +  ac_status=$?
2141 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2142    (exit $ac_status); }; }; then
2143 <  ac_cv_prog_cc_stdc=$ac_arg
2440 < break
2143 >  :
2144   else
2145    echo "$as_me: failed program was:" >&5
2146   sed 's/^/| /' conftest.$ac_ext >&5
2147  
2148 + continue
2149   fi
2150 < rm -f conftest.$ac_objext
2447 < done
2448 < 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
2471 < _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
2150 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2151    cat >conftest.$ac_ext <<_ACEOF
2494 #line $LINENO "configure"
2152   /* confdefs.h.  */
2153   _ACEOF
2154   cat confdefs.h >>conftest.$ac_ext
2155   cat >>conftest.$ac_ext <<_ACEOF
2156   /* end confdefs.h.  */
2500 #include <stdlib.h>
2157   $ac_declaration
2158   int
2159   main ()
# Line 2509 | Line 2165 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2165   _ACEOF
2166   rm -f conftest.$ac_objext
2167   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2168 <  (eval $ac_compile) 2>&5
2168 >  (eval $ac_compile) 2>conftest.er1
2169    ac_status=$?
2170 +  grep -v '^ *+' conftest.er1 >conftest.err
2171 +  rm -f conftest.er1
2172 +  cat conftest.err >&5
2173    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2174    (exit $ac_status); } &&
2175 <         { ac_try='test -s conftest.$ac_objext'
2175 >         { ac_try='test -z "$ac_cxx_werror_flag"
2176 >                         || test ! -s conftest.err'
2177    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2178    (eval $ac_try) 2>&5
2179    ac_status=$?
2180    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2181 <  (exit $ac_status); }; }; then
2182 <  :
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'
2181 >  (exit $ac_status); }; } &&
2182 >         { ac_try='test -s conftest.$ac_objext'
2183    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2184    (eval $ac_try) 2>&5
2185    ac_status=$?
# Line 2561 | Line 2191 | fi
2191   sed 's/^/| /' conftest.$ac_ext >&5
2192  
2193   fi
2194 < rm -f conftest.$ac_objext conftest.$ac_ext
2194 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2195   done
2196   rm -f conftest*
2197   if test -n "$ac_declaration"; then
# Line 2570 | Line 2200 | fi
2200    echo '#endif'             >>confdefs.h
2201   fi
2202  
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
2203   ac_ext=c
2204   ac_cpp='$CPP $CPPFLAGS'
2205   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2206   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2207   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2208  
2209 <
2210 < ac_ext=cc
2211 < ac_cpp='$CXXCPP $CPPFLAGS'
2212 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2213 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2590 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2209 > ac_ext=c
2210 > ac_cpp='$CPP $CPPFLAGS'
2211 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2212 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2213 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2214   if test -n "$ac_tool_prefix"; then
2215 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2215 >  for ac_prog in icc pgcc pathcc cc xlc gcc
2216    do
2217      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2218   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2219   echo "$as_me:$LINENO: checking for $ac_word" >&5
2220   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2221 < if test "${ac_cv_prog_CXX+set}" = set; then
2221 > if test "${ac_cv_prog_CC+set}" = set; then
2222    echo $ECHO_N "(cached) $ECHO_C" >&6
2223   else
2224 <  if test -n "$CXX"; then
2225 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2224 >  if test -n "$CC"; then
2225 >  ac_cv_prog_CC="$CC" # Let the user override the test.
2226   else
2227   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2228   for as_dir in $PATH
# Line 2608 | Line 2231 | do
2231    test -z "$as_dir" && as_dir=.
2232    for ac_exec_ext in '' $ac_executable_extensions; do
2233    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2234 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2234 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2235      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2236      break 2
2237    fi
# Line 2617 | Line 2240 | fi
2240  
2241   fi
2242   fi
2243 < CXX=$ac_cv_prog_CXX
2244 < if test -n "$CXX"; then
2245 <  echo "$as_me:$LINENO: result: $CXX" >&5
2246 < echo "${ECHO_T}$CXX" >&6
2243 > CC=$ac_cv_prog_CC
2244 > if test -n "$CC"; then
2245 >  echo "$as_me:$LINENO: result: $CC" >&5
2246 > echo "${ECHO_T}$CC" >&6
2247   else
2248    echo "$as_me:$LINENO: result: no" >&5
2249   echo "${ECHO_T}no" >&6
2250   fi
2251  
2252 <    test -n "$CXX" && break
2252 >    test -n "$CC" && break
2253    done
2254   fi
2255 < if test -z "$CXX"; then
2256 <  ac_ct_CXX=$CXX
2257 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2255 > if test -z "$CC"; then
2256 >  ac_ct_CC=$CC
2257 >  for ac_prog in icc pgcc pathcc cc xlc gcc
2258   do
2259    # Extract the first word of "$ac_prog", so it can be a program name with args.
2260   set dummy $ac_prog; ac_word=$2
2261   echo "$as_me:$LINENO: checking for $ac_word" >&5
2262   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2263 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2263 > if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2264    echo $ECHO_N "(cached) $ECHO_C" >&6
2265   else
2266 <  if test -n "$ac_ct_CXX"; then
2267 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2266 >  if test -n "$ac_ct_CC"; then
2267 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2268   else
2269   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2270   for as_dir in $PATH
# Line 2650 | Line 2273 | do
2273    test -z "$as_dir" && as_dir=.
2274    for ac_exec_ext in '' $ac_executable_extensions; do
2275    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2276 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2276 >    ac_cv_prog_ac_ct_CC="$ac_prog"
2277      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2278      break 2
2279    fi
# Line 2659 | Line 2282 | fi
2282  
2283   fi
2284   fi
2285 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2286 < if test -n "$ac_ct_CXX"; then
2287 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2288 < echo "${ECHO_T}$ac_ct_CXX" >&6
2285 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
2286 > if test -n "$ac_ct_CC"; then
2287 >  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2288 > echo "${ECHO_T}$ac_ct_CC" >&6
2289   else
2290    echo "$as_me:$LINENO: result: no" >&5
2291   echo "${ECHO_T}no" >&6
2292   fi
2293  
2294 <  test -n "$ac_ct_CXX" && break
2294 >  test -n "$ac_ct_CC" && break
2295   done
2673 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2296  
2297 <  CXX=$ac_ct_CXX
2297 >  CC=$ac_ct_CC
2298   fi
2299  
2300  
2301 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2302 + See \`config.log' for more details." >&5
2303 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2304 + See \`config.log' for more details." >&2;}
2305 +   { (exit 1); exit 1; }; }
2306 +
2307   # Provide some information about the compiler.
2308   echo "$as_me:$LINENO:" \
2309 <     "checking for C++ compiler version" >&5
2309 >     "checking for C compiler version" >&5
2310   ac_compiler=`set X $ac_compile; echo $2`
2311   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2312    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2696 | Line 2324 | ac_compiler=`set X $ac_compile; echo $2`
2324    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2325    (exit $ac_status); }
2326  
2327 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2328 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2329 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2327 > echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2328 > echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2329 > if test "${ac_cv_c_compiler_gnu+set}" = set; then
2330    echo $ECHO_N "(cached) $ECHO_C" >&6
2331   else
2332    cat >conftest.$ac_ext <<_ACEOF
2705 #line $LINENO "configure"
2333   /* confdefs.h.  */
2334   _ACEOF
2335   cat confdefs.h >>conftest.$ac_ext
# Line 2722 | Line 2349 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2349   _ACEOF
2350   rm -f conftest.$ac_objext
2351   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2352 <  (eval $ac_compile) 2>&5
2352 >  (eval $ac_compile) 2>conftest.er1
2353    ac_status=$?
2354 +  grep -v '^ *+' conftest.er1 >conftest.err
2355 +  rm -f conftest.er1
2356 +  cat conftest.err >&5
2357    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2358    (exit $ac_status); } &&
2359 <         { ac_try='test -s conftest.$ac_objext'
2359 >         { ac_try='test -z "$ac_c_werror_flag"
2360 >                         || test ! -s conftest.err'
2361    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2362    (eval $ac_try) 2>&5
2363    ac_status=$?
2364    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2365 +  (exit $ac_status); }; } &&
2366 +         { ac_try='test -s conftest.$ac_objext'
2367 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2368 +  (eval $ac_try) 2>&5
2369 +  ac_status=$?
2370 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2371    (exit $ac_status); }; }; then
2372    ac_compiler_gnu=yes
2373   else
# Line 2739 | Line 2376 | fi
2376  
2377   ac_compiler_gnu=no
2378   fi
2379 < rm -f conftest.$ac_objext conftest.$ac_ext
2380 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2379 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2380 > ac_cv_c_compiler_gnu=$ac_compiler_gnu
2381  
2382   fi
2383 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2384 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2385 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2386 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2387 < ac_save_CXXFLAGS=$CXXFLAGS
2388 < CXXFLAGS="-g"
2389 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2390 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2391 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2383 > echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2384 > echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2385 > GCC=`test $ac_compiler_gnu = yes && echo yes`
2386 > ac_test_CFLAGS=${CFLAGS+set}
2387 > ac_save_CFLAGS=$CFLAGS
2388 > CFLAGS="-g"
2389 > echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2390 > echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2391 > if test "${ac_cv_prog_cc_g+set}" = set; then
2392    echo $ECHO_N "(cached) $ECHO_C" >&6
2393   else
2394    cat >conftest.$ac_ext <<_ACEOF
2758 #line $LINENO "configure"
2395   /* confdefs.h.  */
2396   _ACEOF
2397   cat confdefs.h >>conftest.$ac_ext
# Line 2772 | Line 2408 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2408   _ACEOF
2409   rm -f conftest.$ac_objext
2410   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2411 <  (eval $ac_compile) 2>&5
2411 >  (eval $ac_compile) 2>conftest.er1
2412    ac_status=$?
2413 +  grep -v '^ *+' conftest.er1 >conftest.err
2414 +  rm -f conftest.er1
2415 +  cat conftest.err >&5
2416    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2417    (exit $ac_status); } &&
2418 <         { ac_try='test -s conftest.$ac_objext'
2418 >         { ac_try='test -z "$ac_c_werror_flag"
2419 >                         || test ! -s conftest.err'
2420    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2421    (eval $ac_try) 2>&5
2422    ac_status=$?
2423    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2424 +  (exit $ac_status); }; } &&
2425 +         { ac_try='test -s conftest.$ac_objext'
2426 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2427 +  (eval $ac_try) 2>&5
2428 +  ac_status=$?
2429 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2430    (exit $ac_status); }; }; then
2431 <  ac_cv_prog_cxx_g=yes
2431 >  ac_cv_prog_cc_g=yes
2432   else
2433    echo "$as_me: failed program was:" >&5
2434   sed 's/^/| /' conftest.$ac_ext >&5
2435  
2436 < ac_cv_prog_cxx_g=no
2436 > ac_cv_prog_cc_g=no
2437   fi
2438 < rm -f conftest.$ac_objext conftest.$ac_ext
2438 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2439   fi
2440 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2441 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2442 < if test "$ac_test_CXXFLAGS" = set; then
2443 <  CXXFLAGS=$ac_save_CXXFLAGS
2444 < elif test $ac_cv_prog_cxx_g = yes; then
2445 <  if test "$GXX" = yes; then
2446 <    CXXFLAGS="-g -O2"
2440 > echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2441 > echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2442 > if test "$ac_test_CFLAGS" = set; then
2443 >  CFLAGS=$ac_save_CFLAGS
2444 > elif test $ac_cv_prog_cc_g = yes; then
2445 >  if test "$GCC" = yes; then
2446 >    CFLAGS="-g -O2"
2447    else
2448 <    CXXFLAGS="-g"
2448 >    CFLAGS="-g"
2449    fi
2450   else
2451 <  if test "$GXX" = yes; then
2452 <    CXXFLAGS="-O2"
2451 >  if test "$GCC" = yes; then
2452 >    CFLAGS="-O2"
2453    else
2454 <    CXXFLAGS=
2454 >    CFLAGS=
2455    fi
2456   fi
2457 < for ac_declaration in \
2458 <   ''\
2459 <   '#include <stdlib.h>' \
2457 > echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2458 > echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2459 > if test "${ac_cv_prog_cc_stdc+set}" = set; then
2460 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2461 > else
2462 >  ac_cv_prog_cc_stdc=no
2463 > ac_save_CC=$CC
2464 > cat >conftest.$ac_ext <<_ACEOF
2465 > /* confdefs.h.  */
2466 > _ACEOF
2467 > cat confdefs.h >>conftest.$ac_ext
2468 > cat >>conftest.$ac_ext <<_ACEOF
2469 > /* end confdefs.h.  */
2470 > #include <stdarg.h>
2471 > #include <stdio.h>
2472 > #include <sys/types.h>
2473 > #include <sys/stat.h>
2474 > /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2475 > struct buf { int x; };
2476 > FILE * (*rcsopen) (struct buf *, struct stat *, int);
2477 > static char *e (p, i)
2478 >     char **p;
2479 >     int i;
2480 > {
2481 >  return p[i];
2482 > }
2483 > static char *f (char * (*g) (char **, int), char **p, ...)
2484 > {
2485 >  char *s;
2486 >  va_list v;
2487 >  va_start (v,p);
2488 >  s = g (p, va_arg (v,int));
2489 >  va_end (v);
2490 >  return s;
2491 > }
2492 >
2493 > /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2494 >   function prototypes and stuff, but not '\xHH' hex character constants.
2495 >   These don't provoke an error unfortunately, instead are silently treated
2496 >   as 'x'.  The following induces an error, until -std1 is added to get
2497 >   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2498 >   array size at least.  It's necessary to write '\x00'==0 to get something
2499 >   that's true only with -std1.  */
2500 > int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2501 >
2502 > int test (int i, double x);
2503 > struct s1 {int (*f) (int a);};
2504 > struct s2 {int (*f) (double a);};
2505 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2506 > int argc;
2507 > char **argv;
2508 > int
2509 > main ()
2510 > {
2511 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2512 >  ;
2513 >  return 0;
2514 > }
2515 > _ACEOF
2516 > # Don't try gcc -ansi; that turns off useful extensions and
2517 > # breaks some systems' header files.
2518 > # AIX                   -qlanglvl=ansi
2519 > # Ultrix and OSF/1      -std1
2520 > # HP-UX 10.20 and later -Ae
2521 > # HP-UX older versions  -Aa -D_HPUX_SOURCE
2522 > # SVR4                  -Xc -D__EXTENSIONS__
2523 > for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2524 > do
2525 >  CC="$ac_save_CC $ac_arg"
2526 >  rm -f conftest.$ac_objext
2527 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2528 >  (eval $ac_compile) 2>conftest.er1
2529 >  ac_status=$?
2530 >  grep -v '^ *+' conftest.er1 >conftest.err
2531 >  rm -f conftest.er1
2532 >  cat conftest.err >&5
2533 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2534 >  (exit $ac_status); } &&
2535 >         { ac_try='test -z "$ac_c_werror_flag"
2536 >                         || test ! -s conftest.err'
2537 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2538 >  (eval $ac_try) 2>&5
2539 >  ac_status=$?
2540 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2541 >  (exit $ac_status); }; } &&
2542 >         { ac_try='test -s conftest.$ac_objext'
2543 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2544 >  (eval $ac_try) 2>&5
2545 >  ac_status=$?
2546 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2547 >  (exit $ac_status); }; }; then
2548 >  ac_cv_prog_cc_stdc=$ac_arg
2549 > break
2550 > else
2551 >  echo "$as_me: failed program was:" >&5
2552 > sed 's/^/| /' conftest.$ac_ext >&5
2553 >
2554 > fi
2555 > rm -f conftest.err conftest.$ac_objext
2556 > done
2557 > rm -f conftest.$ac_ext conftest.$ac_objext
2558 > CC=$ac_save_CC
2559 >
2560 > fi
2561 >
2562 > case "x$ac_cv_prog_cc_stdc" in
2563 >  x|xno)
2564 >    echo "$as_me:$LINENO: result: none needed" >&5
2565 > echo "${ECHO_T}none needed" >&6 ;;
2566 >  *)
2567 >    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2568 > echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2569 >    CC="$CC $ac_cv_prog_cc_stdc" ;;
2570 > esac
2571 >
2572 > # Some people use a C++ compiler to compile C.  Since we use `exit',
2573 > # in C++ we need to declare it.  In case someone uses the same compiler
2574 > # for both compiling C and C++ we need to have the C++ compiler decide
2575 > # the declaration of exit, since it's the most demanding environment.
2576 > cat >conftest.$ac_ext <<_ACEOF
2577 > #ifndef __cplusplus
2578 >  choke me
2579 > #endif
2580 > _ACEOF
2581 > rm -f conftest.$ac_objext
2582 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2583 >  (eval $ac_compile) 2>conftest.er1
2584 >  ac_status=$?
2585 >  grep -v '^ *+' conftest.er1 >conftest.err
2586 >  rm -f conftest.er1
2587 >  cat conftest.err >&5
2588 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2589 >  (exit $ac_status); } &&
2590 >         { ac_try='test -z "$ac_c_werror_flag"
2591 >                         || test ! -s conftest.err'
2592 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2593 >  (eval $ac_try) 2>&5
2594 >  ac_status=$?
2595 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2596 >  (exit $ac_status); }; } &&
2597 >         { ac_try='test -s conftest.$ac_objext'
2598 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2599 >  (eval $ac_try) 2>&5
2600 >  ac_status=$?
2601 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2602 >  (exit $ac_status); }; }; then
2603 >  for ac_declaration in \
2604 >   '' \
2605     'extern "C" void std::exit (int) throw (); using std::exit;' \
2606     'extern "C" void std::exit (int); using std::exit;' \
2607     'extern "C" void exit (int) throw ();' \
# Line 2818 | Line 2609 | do
2609     'void exit (int);'
2610   do
2611    cat >conftest.$ac_ext <<_ACEOF
2821 #line $LINENO "configure"
2612   /* confdefs.h.  */
2613   _ACEOF
2614   cat confdefs.h >>conftest.$ac_ext
2615   cat >>conftest.$ac_ext <<_ACEOF
2616   /* end confdefs.h.  */
2827 #include <stdlib.h>
2617   $ac_declaration
2618 + #include <stdlib.h>
2619   int
2620   main ()
2621   {
# Line 2836 | Line 2626 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2626   _ACEOF
2627   rm -f conftest.$ac_objext
2628   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2629 <  (eval $ac_compile) 2>&5
2629 >  (eval $ac_compile) 2>conftest.er1
2630    ac_status=$?
2631 +  grep -v '^ *+' conftest.er1 >conftest.err
2632 +  rm -f conftest.er1
2633 +  cat conftest.err >&5
2634    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2635    (exit $ac_status); } &&
2636 <         { ac_try='test -s conftest.$ac_objext'
2636 >         { ac_try='test -z "$ac_c_werror_flag"
2637 >                         || test ! -s conftest.err'
2638    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2639    (eval $ac_try) 2>&5
2640    ac_status=$?
2641    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2642 +  (exit $ac_status); }; } &&
2643 +         { ac_try='test -s conftest.$ac_objext'
2644 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2645 +  (eval $ac_try) 2>&5
2646 +  ac_status=$?
2647 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2648    (exit $ac_status); }; }; then
2649    :
2650   else
# Line 2853 | Line 2653 | fi
2653  
2654   continue
2655   fi
2656 < rm -f conftest.$ac_objext conftest.$ac_ext
2656 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2657    cat >conftest.$ac_ext <<_ACEOF
2858 #line $LINENO "configure"
2658   /* confdefs.h.  */
2659   _ACEOF
2660   cat confdefs.h >>conftest.$ac_ext
# Line 2872 | Line 2671 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2671   _ACEOF
2672   rm -f conftest.$ac_objext
2673   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2674 <  (eval $ac_compile) 2>&5
2674 >  (eval $ac_compile) 2>conftest.er1
2675    ac_status=$?
2676 +  grep -v '^ *+' conftest.er1 >conftest.err
2677 +  rm -f conftest.er1
2678 +  cat conftest.err >&5
2679    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2680    (exit $ac_status); } &&
2681 <         { ac_try='test -s conftest.$ac_objext'
2681 >         { ac_try='test -z "$ac_c_werror_flag"
2682 >                         || test ! -s conftest.err'
2683    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2684    (eval $ac_try) 2>&5
2685    ac_status=$?
2686    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2687 +  (exit $ac_status); }; } &&
2688 +         { ac_try='test -s conftest.$ac_objext'
2689 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2690 +  (eval $ac_try) 2>&5
2691 +  ac_status=$?
2692 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2693    (exit $ac_status); }; }; then
2694    break
2695   else
# Line 2888 | Line 2697 | fi
2697   sed 's/^/| /' conftest.$ac_ext >&5
2698  
2699   fi
2700 < rm -f conftest.$ac_objext conftest.$ac_ext
2700 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2701   done
2702   rm -f conftest*
2703   if test -n "$ac_declaration"; then
# Line 2897 | Line 2706 | fi
2706    echo '#endif'             >>confdefs.h
2707   fi
2708  
2709 + else
2710 +  echo "$as_me: failed program was:" >&5
2711 + sed 's/^/| /' conftest.$ac_ext >&5
2712 +
2713 + fi
2714 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2715   ac_ext=c
2716   ac_cpp='$CPP $CPPFLAGS'
2717   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2718   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2719   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2720  
2721 <
2722 < OOPSE_TEMPLATE_FLAGS=""
2723 < if test $ac_cv_cxx_compiler_gnu = no; then
2724 <  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
2721 > ac_ext=${FC_SRCEXT-f}
2722 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2723 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2724 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2725   if test -n "$ac_tool_prefix"; then
2726 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2726 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2727    do
2728      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2729   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2730   echo "$as_me:$LINENO: checking for $ac_word" >&5
2731   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2732 < if test "${ac_cv_prog_F90+set}" = set; then
2732 > if test "${ac_cv_prog_FC+set}" = set; then
2733    echo $ECHO_N "(cached) $ECHO_C" >&6
2734   else
2735 <  if test -n "$F90"; then
2736 <  ac_cv_prog_F90="$F90" # Let the user override the test.
2735 >  if test -n "$FC"; then
2736 >  ac_cv_prog_FC="$FC" # Let the user override the test.
2737   else
2738   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2739   for as_dir in $PATH
# Line 2984 | Line 2742 | do
2742    test -z "$as_dir" && as_dir=.
2743    for ac_exec_ext in '' $ac_executable_extensions; do
2744    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2745 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
2745 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2746      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2747      break 2
2748    fi
# Line 2993 | Line 2751 | fi
2751  
2752   fi
2753   fi
2754 < F90=$ac_cv_prog_F90
2755 < if test -n "$F90"; then
2756 <  echo "$as_me:$LINENO: result: $F90" >&5
2757 < echo "${ECHO_T}$F90" >&6
2754 > FC=$ac_cv_prog_FC
2755 > if test -n "$FC"; then
2756 >  echo "$as_me:$LINENO: result: $FC" >&5
2757 > echo "${ECHO_T}$FC" >&6
2758   else
2759    echo "$as_me:$LINENO: result: no" >&5
2760   echo "${ECHO_T}no" >&6
2761   fi
2762  
2763 <    test -n "$F90" && break
2763 >    test -n "$FC" && break
2764    done
2765   fi
2766 < if test -z "$F90"; then
2767 <  ac_ct_F90=$F90
2768 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2766 > if test -z "$FC"; then
2767 >  ac_ct_FC=$FC
2768 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2769   do
2770    # Extract the first word of "$ac_prog", so it can be a program name with args.
2771   set dummy $ac_prog; ac_word=$2
2772   echo "$as_me:$LINENO: checking for $ac_word" >&5
2773   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2774 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
2774 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2775    echo $ECHO_N "(cached) $ECHO_C" >&6
2776   else
2777 <  if test -n "$ac_ct_F90"; then
2778 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
2777 >  if test -n "$ac_ct_FC"; then
2778 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2779   else
2780   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2781   for as_dir in $PATH
# Line 3026 | Line 2784 | do
2784    test -z "$as_dir" && as_dir=.
2785    for ac_exec_ext in '' $ac_executable_extensions; do
2786    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2787 <    ac_cv_prog_ac_ct_F90="$ac_prog"
2787 >    ac_cv_prog_ac_ct_FC="$ac_prog"
2788      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2789      break 2
2790    fi
# Line 3035 | Line 2793 | fi
2793  
2794   fi
2795   fi
2796 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
2797 < if test -n "$ac_ct_F90"; then
2798 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
2799 < echo "${ECHO_T}$ac_ct_F90" >&6
2796 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
2797 > if test -n "$ac_ct_FC"; then
2798 >  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2799 > echo "${ECHO_T}$ac_ct_FC" >&6
2800   else
2801    echo "$as_me:$LINENO: result: no" >&5
2802   echo "${ECHO_T}no" >&6
2803   fi
2804  
2805 <  test -n "$ac_ct_F90" && break
2805 >  test -n "$ac_ct_FC" && break
2806   done
2807  
2808 <  F90=$ac_ct_F90
2808 >  FC=$ac_ct_FC
2809   fi
2810  
2811  
2812 < # If we don't use `.F90' as extension, the preprocessor is not run on the
2813 < # input file.
2812 > # Provide some information about the compiler.
2813 > echo "$as_me:2813:" \
2814 >     "checking for Fortran compiler version" >&5
2815 > ac_compiler=`set X $ac_compile; echo $2`
2816 > { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2817 >  (eval $ac_compiler --version </dev/null >&5) 2>&5
2818 >  ac_status=$?
2819 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2820 >  (exit $ac_status); }
2821 > { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2822 >  (eval $ac_compiler -v </dev/null >&5) 2>&5
2823 >  ac_status=$?
2824 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2825 >  (exit $ac_status); }
2826 > { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2827 >  (eval $ac_compiler -V </dev/null >&5) 2>&5
2828 >  ac_status=$?
2829 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2830 >  (exit $ac_status); }
2831 > rm -f a.out
2832 >
2833 > # If we don't use `.F' as extension, the preprocessor is not run on the
2834 > # input file.  (Note that this only needs to work for GNU compilers.)
2835   ac_save_ext=$ac_ext
2836 < ac_ext=F90
2837 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
2838 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
2839 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
2836 > ac_ext=F
2837 > echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2838 > echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2839 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2840    echo $ECHO_N "(cached) $ECHO_C" >&6
2841   else
2842    cat >conftest.$ac_ext <<_ACEOF
2843 <
3065 < program main
3066 <
2843 >      program main
2844   #ifndef __GNUC__
2845         choke me
2846   #endif
2847  
2848 < end program main
3072 <
2848 >      end
2849   _ACEOF
2850   rm -f conftest.$ac_objext
2851   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2852 <  (eval $ac_compile) 2>&5
2852 >  (eval $ac_compile) 2>conftest.er1
2853    ac_status=$?
2854 +  grep -v '^ *+' conftest.er1 >conftest.err
2855 +  rm -f conftest.er1
2856 +  cat conftest.err >&5
2857    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2858    (exit $ac_status); } &&
2859 <         { ac_try='test -s conftest.$ac_objext'
2859 >         { ac_try='test -z "$ac_fc_werror_flag"
2860 >                         || test ! -s conftest.err'
2861    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2862    (eval $ac_try) 2>&5
2863    ac_status=$?
2864    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2865 +  (exit $ac_status); }; } &&
2866 +         { ac_try='test -s conftest.$ac_objext'
2867 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2868 +  (eval $ac_try) 2>&5
2869 +  ac_status=$?
2870 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2871    (exit $ac_status); }; }; then
2872    ac_compiler_gnu=yes
2873   else
# Line 3090 | Line 2876 | fi
2876  
2877   ac_compiler_gnu=no
2878   fi
2879 < rm -f conftest.$ac_objext conftest.$ac_ext
2880 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
2879 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2880 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2881  
2882   fi
2883 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
2884 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
2883 > echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2884 > echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2885   ac_ext=$ac_save_ext
2886 < G95=`test $ac_compiler_gnu = yes && echo yes`
2887 < ac_ext=c
2888 < ac_cpp='$CPP $CPPFLAGS'
2889 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2890 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2891 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
2886 > ac_test_FFLAGS=${FCFLAGS+set}
2887 > ac_save_FFLAGS=$FCFLAGS
2888 > FCFLAGS=
2889 > echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2890 > echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2891 > if test "${ac_cv_prog_fc_g+set}" = set; then
2892 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2893 > else
2894 >  FCFLAGS=-g
2895 > cat >conftest.$ac_ext <<_ACEOF
2896 >      program main
2897  
2898 <
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 <
2898 >      end
2899   _ACEOF
2900   rm -f conftest.$ac_objext
2901   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2902 <  (eval $ac_compile) 2>&5
2902 >  (eval $ac_compile) 2>conftest.er1
2903    ac_status=$?
2904 +  grep -v '^ *+' conftest.er1 >conftest.err
2905 +  rm -f conftest.er1
2906 +  cat conftest.err >&5
2907    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2908    (exit $ac_status); } &&
2909 <         { ac_try='test -s conftest.$ac_objext'
2909 >         { ac_try='test -z "$ac_fc_werror_flag"
2910 >                         || test ! -s conftest.err'
2911    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2912    (eval $ac_try) 2>&5
2913    ac_status=$?
2914    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2915 +  (exit $ac_status); }; } &&
2916 +         { ac_try='test -s conftest.$ac_objext'
2917 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2918 +  (eval $ac_try) 2>&5
2919 +  ac_status=$?
2920 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2921    (exit $ac_status); }; }; then
2922 <  prepflagworks=1
2922 >  ac_cv_prog_fc_g=yes
2923   else
2924    echo "$as_me: failed program was:" >&5
2925   sed 's/^/| /' conftest.$ac_ext >&5
2926  
2927 < prepflagworks=0
2927 > ac_cv_prog_fc_g=no
2928   fi
2929 < rm -f conftest.$ac_objext conftest.$ac_ext
2929 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2930  
2931 <  F90FLAGS=$ac_save_F90FLAGS
2932 <  ac_ext=$ac_save_ext
2933 <  ac_ext=c
2931 > fi
2932 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2933 > echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2934 > if test "$ac_test_FFLAGS" = set; then
2935 >  FCFLAGS=$ac_save_FFLAGS
2936 > elif test $ac_cv_prog_fc_g = yes; then
2937 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2938 >    FCFLAGS="-g -O2"
2939 >  else
2940 >    FCFLAGS="-g"
2941 >  fi
2942 > else
2943 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2944 >    FCFLAGS="-O2"
2945 >  else
2946 >    FCFLAGS=
2947 >  fi
2948 > fi
2949 >
2950 > ac_ext=c
2951   ac_cpp='$CPP $CPPFLAGS'
2952   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2953   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2954   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2955  
2956 + ac_ext=c
2957 + ac_cpp='$CPP $CPPFLAGS'
2958 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2959 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2960 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2961 + echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2962 + echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2963 + # On Suns, sometimes $CPP names a directory.
2964 + if test -n "$CPP" && test -d "$CPP"; then
2965 +  CPP=
2966 + fi
2967 + if test -z "$CPP"; then
2968 +  if test "${ac_cv_prog_CPP+set}" = set; then
2969 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2970 + else
2971 +      # Double quotes because CPP needs to be expanded
2972 +    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
2973 +    do
2974 +      ac_preproc_ok=false
2975 + for ac_c_preproc_warn_flag in '' yes
2976 + do
2977 +  # Use a header file that comes with gcc, so configuring glibc
2978 +  # with a fresh cross-compiler works.
2979 +  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2980 +  # <limits.h> exists even on freestanding compilers.
2981 +  # On the NeXT, cc -E runs the code through the compiler's parser,
2982 +  # not just through cpp. "Syntax error" is here to catch this case.
2983 +  cat >conftest.$ac_ext <<_ACEOF
2984 + /* confdefs.h.  */
2985 + _ACEOF
2986 + cat confdefs.h >>conftest.$ac_ext
2987 + cat >>conftest.$ac_ext <<_ACEOF
2988 + /* end confdefs.h.  */
2989 + #ifdef __STDC__
2990 + # include <limits.h>
2991 + #else
2992 + # include <assert.h>
2993 + #endif
2994 +                     Syntax error
2995 + _ACEOF
2996 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2997 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2998 +  ac_status=$?
2999 +  grep -v '^ *+' conftest.er1 >conftest.err
3000 +  rm -f conftest.er1
3001 +  cat conftest.err >&5
3002 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3003 +  (exit $ac_status); } >/dev/null; then
3004 +  if test -s conftest.err; then
3005 +    ac_cpp_err=$ac_c_preproc_warn_flag
3006 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3007 +  else
3008 +    ac_cpp_err=
3009 +  fi
3010 + else
3011 +  ac_cpp_err=yes
3012 + fi
3013 + if test -z "$ac_cpp_err"; then
3014 +  :
3015 + else
3016 +  echo "$as_me: failed program was:" >&5
3017 + sed 's/^/| /' conftest.$ac_ext >&5
3018  
3019 <  if test "$prepflagworks" = 1; then
3020 <    echo "$as_me:$LINENO: result: yes" >&5
3021 < echo "${ECHO_T}yes" >&6
3019 >  # Broken: fails on valid input.
3020 > continue
3021 > fi
3022 > rm -f conftest.err conftest.$ac_ext
3023  
3024 +  # OK, works on sane cases.  Now check whether non-existent headers
3025 +  # can be detected and how.
3026 +  cat >conftest.$ac_ext <<_ACEOF
3027 + /* confdefs.h.  */
3028 + _ACEOF
3029 + cat confdefs.h >>conftest.$ac_ext
3030 + cat >>conftest.$ac_ext <<_ACEOF
3031 + /* end confdefs.h.  */
3032 + #include <ac_nonexistent.h>
3033 + _ACEOF
3034 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3035 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3036 +  ac_status=$?
3037 +  grep -v '^ *+' conftest.er1 >conftest.err
3038 +  rm -f conftest.er1
3039 +  cat conftest.err >&5
3040 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3041 +  (exit $ac_status); } >/dev/null; then
3042 +  if test -s conftest.err; then
3043 +    ac_cpp_err=$ac_c_preproc_warn_flag
3044 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3045    else
3046 <    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; }; }
3046 >    ac_cpp_err=
3047    fi
3048 + else
3049 +  ac_cpp_err=yes
3050   fi
3051 + if test -z "$ac_cpp_err"; then
3052 +  # Broken: success on invalid input.
3053 + continue
3054 + else
3055 +  echo "$as_me: failed program was:" >&5
3056 + sed 's/^/| /' conftest.$ac_ext >&5
3057  
3058 +  # Passes both tests.
3059 + ac_preproc_ok=:
3060 + break
3061 + fi
3062 + rm -f conftest.err conftest.$ac_ext
3063  
3064 <
3065 <
3066 <
3067 < # Try to determine native compiler flags that allow us to use F90 suffix
3068 < # 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"
3064 > done
3065 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3066 > rm -f conftest.err conftest.$ac_ext
3067 > if $ac_preproc_ok; then
3068 >  break
3069   fi
3070  
3071 <    cat >conftest.$ac_ext <<_ACEOF
3071 >    done
3072 >    ac_cv_prog_CPP=$CPP
3073  
3074 <
3075 < program main
3076 <
3077 <  integer :: i
3078 < #ifdef TEST
3079 <  i = 1
3074 > fi
3075 >  CPP=$ac_cv_prog_CPP
3076 > else
3077 >  ac_cv_prog_CPP=$CPP
3078 > fi
3079 > echo "$as_me:$LINENO: result: $CPP" >&5
3080 > echo "${ECHO_T}$CPP" >&6
3081 > ac_preproc_ok=false
3082 > for ac_c_preproc_warn_flag in '' yes
3083 > do
3084 >  # Use a header file that comes with gcc, so configuring glibc
3085 >  # with a fresh cross-compiler works.
3086 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3087 >  # <limits.h> exists even on freestanding compilers.
3088 >  # On the NeXT, cc -E runs the code through the compiler's parser,
3089 >  # not just through cpp. "Syntax error" is here to catch this case.
3090 >  cat >conftest.$ac_ext <<_ACEOF
3091 > /* confdefs.h.  */
3092 > _ACEOF
3093 > cat confdefs.h >>conftest.$ac_ext
3094 > cat >>conftest.$ac_ext <<_ACEOF
3095 > /* end confdefs.h.  */
3096 > #ifdef __STDC__
3097 > # include <limits.h>
3098   #else
3099 <  choke me
3099 > # include <assert.h>
3100   #endif
3101 +                     Syntax error
3102 + _ACEOF
3103 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3104 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3105 +  ac_status=$?
3106 +  grep -v '^ *+' conftest.er1 >conftest.err
3107 +  rm -f conftest.er1
3108 +  cat conftest.err >&5
3109 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3110 +  (exit $ac_status); } >/dev/null; then
3111 +  if test -s conftest.err; then
3112 +    ac_cpp_err=$ac_c_preproc_warn_flag
3113 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3114 +  else
3115 +    ac_cpp_err=
3116 +  fi
3117 + else
3118 +  ac_cpp_err=yes
3119 + fi
3120 + if test -z "$ac_cpp_err"; then
3121 +  :
3122 + else
3123 +  echo "$as_me: failed program was:" >&5
3124 + sed 's/^/| /' conftest.$ac_ext >&5
3125  
3126 +  # Broken: fails on valid input.
3127 + continue
3128 + fi
3129 + rm -f conftest.err conftest.$ac_ext
3130  
3131 < end program main
3132 <
3131 >  # OK, works on sane cases.  Now check whether non-existent headers
3132 >  # can be detected and how.
3133 >  cat >conftest.$ac_ext <<_ACEOF
3134 > /* confdefs.h.  */
3135   _ACEOF
3136 < rm -f conftest.$ac_objext
3137 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3138 <  (eval $ac_compile) 2>&5
3136 > cat confdefs.h >>conftest.$ac_ext
3137 > cat >>conftest.$ac_ext <<_ACEOF
3138 > /* end confdefs.h.  */
3139 > #include <ac_nonexistent.h>
3140 > _ACEOF
3141 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3142 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3143    ac_status=$?
3144 +  grep -v '^ *+' conftest.er1 >conftest.err
3145 +  rm -f conftest.er1
3146 +  cat conftest.err >&5
3147    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3148 <  (exit $ac_status); } &&
3149 <         { ac_try='test -s conftest.$ac_objext'
3150 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3151 <  (eval $ac_try) 2>&5
3152 <  ac_status=$?
3153 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3154 <  (exit $ac_status); }; }; then
3282 <  prepdefflagworks=1
3148 >  (exit $ac_status); } >/dev/null; then
3149 >  if test -s conftest.err; then
3150 >    ac_cpp_err=$ac_c_preproc_warn_flag
3151 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3152 >  else
3153 >    ac_cpp_err=
3154 >  fi
3155   else
3156 +  ac_cpp_err=yes
3157 + fi
3158 + if test -z "$ac_cpp_err"; then
3159 +  # Broken: success on invalid input.
3160 + continue
3161 + else
3162    echo "$as_me: failed program was:" >&5
3163   sed 's/^/| /' conftest.$ac_ext >&5
3164  
3165 < prepdefflagworks=0
3165 >  # Passes both tests.
3166 > ac_preproc_ok=:
3167 > break
3168   fi
3169 < rm -f conftest.$ac_objext conftest.$ac_ext
3169 > rm -f conftest.err conftest.$ac_ext
3170  
3171 <  F90FLAGS=$ac_save_F90FLAGS
3172 <  ac_ext=$ac_save_ext
3173 <  ac_ext=c
3171 > done
3172 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3173 > rm -f conftest.err conftest.$ac_ext
3174 > if $ac_preproc_ok; then
3175 >  :
3176 > else
3177 >  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3178 > See \`config.log' for more details." >&5
3179 > echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3180 > See \`config.log' for more details." >&2;}
3181 >   { (exit 1); exit 1; }; }
3182 > fi
3183 >
3184 > ac_ext=c
3185   ac_cpp='$CPP $CPPFLAGS'
3186   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3187   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3188   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3189  
3190 + echo "$as_me:$LINENO: checking for egrep" >&5
3191 + echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3192 + if test "${ac_cv_prog_egrep+set}" = set; then
3193 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3194 + else
3195 +  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3196 +    then ac_cv_prog_egrep='grep -E'
3197 +    else ac_cv_prog_egrep='egrep'
3198 +    fi
3199 + fi
3200 + echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3201 + echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3202 + EGREP=$ac_cv_prog_egrep
3203  
3204  
3205 <  if test "$prepdefflagworks" = 1; then
3206 <    echo "$as_me:$LINENO: result: yes" >&5
3205 > echo "$as_me:$LINENO: checking whether ln -s works" >&5
3206 > echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3207 > LN_S=$as_ln_s
3208 > if test "$LN_S" = "ln -s"; then
3209 >  echo "$as_me:$LINENO: result: yes" >&5
3210   echo "${ECHO_T}yes" >&6
3211 <
3212 <  else
3213 <    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
3211 > else
3212 >  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3213 > echo "${ECHO_T}no, using $LN_S" >&6
3214   fi
3215  
3216 < ac_ext=f90
3217 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3218 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3219 < 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
3216 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3217 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3218 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3219 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3220    echo $ECHO_N "(cached) $ECHO_C" >&6
3221   else
3222 <
3223 < cat >conftest.$ac_ext <<_ACEOF
3224 <
3333 < program main
3334 <
3335 <
3336 < end program main
3337 <
3222 >  cat >conftest.make <<\_ACEOF
3223 > all:
3224 >        @echo 'ac_maketemp="$(MAKE)"'
3225   _ACEOF
3226 < rm -f conftest.$ac_objext
3227 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3228 <  (eval $ac_compile) 2>&5
3229 <  ac_status=$?
3230 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3231 <  (exit $ac_status); } &&
3232 <         { ac_try='test -s conftest.$ac_objext'
3233 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3234 <  (eval $ac_try) 2>&5
3235 <  ac_status=$?
3236 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3237 <  (exit $ac_status); }; }; then
3238 <  ac_cv_prog_f90_v=
3239 < # Try some options frequently used verbose output
3240 < for ac_verb in -v -verbose --verbose -V -\#\#\#; do
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'
3357 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3226 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3227 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3228 > if test -n "$ac_maketemp"; then
3229 >  eval ac_cv_prog_make_${ac_make}_set=yes
3230 > else
3231 >  eval ac_cv_prog_make_${ac_make}_set=no
3232 > fi
3233 > rm -f conftest.make
3234 > fi
3235 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3236 >  echo "$as_me:$LINENO: result: yes" >&5
3237 > echo "${ECHO_T}yes" >&6
3238 >  SET_MAKE=
3239 > else
3240 >  echo "$as_me:$LINENO: result: no" >&5
3241 > echo "${ECHO_T}no" >&6
3242 >  SET_MAKE="MAKE=${MAKE-make}"
3243 > fi
3244  
3245 < cat >conftest.$ac_ext <<_ACEOF
3245 > if test -n "$ac_tool_prefix"; then
3246 >  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3247 > set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3248 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3249 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3250 > if test "${ac_cv_prog_RANLIB+set}" = set; then
3251 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3252 > else
3253 >  if test -n "$RANLIB"; then
3254 >  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3255 > else
3256 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3257 > for as_dir in $PATH
3258 > do
3259 >  IFS=$as_save_IFS
3260 >  test -z "$as_dir" && as_dir=.
3261 >  for ac_exec_ext in '' $ac_executable_extensions; do
3262 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3263 >    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3264 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3265 >    break 2
3266 >  fi
3267 > done
3268 > done
3269  
3270 < program main
3270 > fi
3271 > fi
3272 > RANLIB=$ac_cv_prog_RANLIB
3273 > if test -n "$RANLIB"; then
3274 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3275 > echo "${ECHO_T}$RANLIB" >&6
3276 > else
3277 >  echo "$as_me:$LINENO: result: no" >&5
3278 > echo "${ECHO_T}no" >&6
3279 > fi
3280  
3281 + fi
3282 + if test -z "$ac_cv_prog_RANLIB"; then
3283 +  ac_ct_RANLIB=$RANLIB
3284 +  # Extract the first word of "ranlib", so it can be a program name with args.
3285 + set dummy ranlib; ac_word=$2
3286 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3287 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3288 + if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3289 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3290 + else
3291 +  if test -n "$ac_ct_RANLIB"; then
3292 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3293 + else
3294 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3295 + for as_dir in $PATH
3296 + do
3297 +  IFS=$as_save_IFS
3298 +  test -z "$as_dir" && as_dir=.
3299 +  for ac_exec_ext in '' $ac_executable_extensions; do
3300 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3301 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3302 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3303 +    break 2
3304 +  fi
3305 + done
3306 + done
3307  
3308 < end program main
3308 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3309 > fi
3310 > fi
3311 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3312 > if test -n "$ac_ct_RANLIB"; then
3313 >  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3314 > echo "${ECHO_T}$ac_ct_RANLIB" >&6
3315 > else
3316 >  echo "$as_me:$LINENO: result: no" >&5
3317 > echo "${ECHO_T}no" >&6
3318 > fi
3319  
3320 < _ACEOF
3320 >  RANLIB=$ac_ct_RANLIB
3321 > else
3322 >  RANLIB="$ac_cv_prog_RANLIB"
3323 > fi
3324  
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"
3325  
3326 < (eval echo $as_me:3375: \"$ac_link\") >&5
3327 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3328 < echo "$ac_f90_v_output" >&5
3329 < F90FLAGS=$ac_save_F90FLAGS
3326 >   # Extract the first word of "perl", so it can be a program name with args.
3327 > set dummy perl; ac_word=$2
3328 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3329 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3330 > if test "${ac_cv_path_PERLINTERP+set}" = set; then
3331 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3332 > else
3333 >  case $PERLINTERP in
3334 >  [\\/]* | ?:[\\/]*)
3335 >  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3336 >  ;;
3337 >  *)
3338 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3339 > for as_dir in $PATH
3340 > do
3341 >  IFS=$as_save_IFS
3342 >  test -z "$as_dir" && as_dir=.
3343 >  for ac_exec_ext in '' $ac_executable_extensions; do
3344 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3345 >    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3346 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3347 >    break 2
3348 >  fi
3349 > done
3350 > done
3351  
3352 < rm -f conftest.*
3353 < ac_ext=f90
3354 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3355 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3356 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3352 >  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3353 >  ;;
3354 > esac
3355 > fi
3356 > PERLINTERP=$ac_cv_path_PERLINTERP
3357  
3358 < # If we are using xlf then replace all the commas with spaces.
3359 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3360 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3358 > if test -n "$PERLINTERP"; then
3359 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3360 > echo "${ECHO_T}$PERLINTERP" >&6
3361 > else
3362 >  echo "$as_me:$LINENO: result: no" >&5
3363 > echo "${ECHO_T}no" >&6
3364   fi
3365  
3366 < # If we are using Cray Fortran then delete quotes.
3367 < # Use "\"" instead of '"' for font-lock-mode.
3368 < # FIXME: a more general fix for quoted arguments with spaces?
3369 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3370 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3366 >   ac_cv_path_perlinterp="$PERLINTERP"
3367 >   _sHpB='#!'
3368 >
3369 >
3370 > # Check whether --with-perl-shebang or --without-perl-shebang was given.
3371 > if test "${with_perl_shebang+set}" = set; then
3372 >  withval="$with_perl_shebang"
3373 >  opt_perl_shebang="$withval"
3374 > else
3375 >                opt_perl_shebang="not_set"
3376 > fi;
3377 >   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3378 > echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3379 > if test "${ax_cv_opt_perl_shebang+set}" = set; then
3380 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3381 > else
3382 >   case "$opt_perl_shebang" in
3383 >                      not_set  ) ax_cv_opt_perl_shebang=''
3384 >                               ;;
3385 >                         *     )
3386 >        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3387 >                    esac
3388 >
3389   fi
3390 + echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3391 + echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3392 +   if test "A$ax_cv_opt_perl_shebang" != "A"
3393 +     then
3394 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3395 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3396 +              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3397 + echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3398 +
3399 + # Automatic detection of sharpbang formula starts here
3400 +     else
3401 +   _somian_shbangperl=`$PERLINTERP -V:startperl`
3402 +   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3403 +   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3404 + echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3405 + if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3406 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3407 + else
3408 +  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3409 +        if test "x$_somian_kspb_perl" == x
3410 +          then _somian_ksbp_warn_empty='durnit'
3411 +          else
3412 +          case "A$_somian_kspb_perl" in
3413 +                 A#!*perl* )
3414 +           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3415 +                        ;;
3416 +                     A*    )  _somian_ksbp_warn_defau='trouble'
3417 +                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3418 +          esac
3419 +        fi
3420 +
3421 + fi
3422 + echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3423 + echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3424 + # The above prints Checking ... result message to user.
3425 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3426 +
3427 +    if test A${_somian_ksbp_warn_empty+set} == Aset
3428 +      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3429 + echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3430 +    fi
3431 + # Inform user after printing result value
3432 +    if test A${_somian_ksbp_warn_defau+set} == Aset
3433 +      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3434 + echo "$as_me: Maybe Not good -" >&6;}
3435 +           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3436 + echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3437 +      else { echo "$as_me:$LINENO: OK Good result - " >&5
3438 + echo "$as_me: OK Good result - " >&6;}
3439 +           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3440 + echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3441 +    fi
3442 +  fi
3443 +
3444 + # Find a good install program.  We prefer a C program (faster),
3445 + # so one script is as good as another.  But avoid the broken or
3446 + # incompatible versions:
3447 + # SysV /etc/install, /usr/sbin/install
3448 + # SunOS /usr/etc/install
3449 + # IRIX /sbin/install
3450 + # AIX /bin/install
3451 + # AmigaOS /C/install, which installs bootblocks on floppy discs
3452 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3453 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3454 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3455 + # OS/2's system install, which has a completely different semantic
3456 + # ./install, which can be erroneously created by make from ./install.sh.
3457 + echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3458 + echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3459 + if test -z "$INSTALL"; then
3460 + if test "${ac_cv_path_install+set}" = set; then
3461 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3462 + else
3463 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3464 + for as_dir in $PATH
3465 + do
3466 +  IFS=$as_save_IFS
3467 +  test -z "$as_dir" && as_dir=.
3468 +  # Account for people who put trailing slashes in PATH elements.
3469 + case $as_dir/ in
3470 +  ./ | .// | /cC/* | \
3471 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3472 +  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3473 +  /usr/ucb/* ) ;;
3474 +  *)
3475 +    # OSF1 and SCO ODT 3.0 have their own names for install.
3476 +    # Don't use installbsd from OSF since it installs stuff as root
3477 +    # by default.
3478 +    for ac_prog in ginstall scoinst install; do
3479 +      for ac_exec_ext in '' $ac_executable_extensions; do
3480 +        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3481 +          if test $ac_prog = install &&
3482 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3483 +            # AIX install.  It has an incompatible calling convention.
3484 +            :
3485 +          elif test $ac_prog = install &&
3486 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3487 +            # program-specific install script used by HP pwplus--don't use.
3488 +            :
3489 +          else
3490 +            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3491 +            break 3
3492 +          fi
3493 +        fi
3494 +      done
3495 +    done
3496 +    ;;
3497 + esac
3498 + done
3499 +
3500 +
3501 + fi
3502 +  if test "${ac_cv_path_install+set}" = set; then
3503 +    INSTALL=$ac_cv_path_install
3504 +  else
3505 +    # As a last resort, use the slow shell script.  We don't cache a
3506 +    # path for INSTALL within a source directory, because that will
3507 +    # break other packages using the cache if that directory is
3508 +    # removed, or if the path is relative.
3509 +    INSTALL=$ac_install_sh
3510 +  fi
3511 + fi
3512 + echo "$as_me:$LINENO: result: $INSTALL" >&5
3513 + echo "${ECHO_T}$INSTALL" >&6
3514 +
3515 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3516 + # It thinks the first close brace ends the variable substitution.
3517 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3518 +
3519 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3520 +
3521 + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3522 +
3523 + case "x$INSTALL" in
3524 +   x/*) ;;
3525 +   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3526 + esac
3527 + MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3528 + # Extract the first word of "ar", so it can be a program name with args.
3529 + set dummy ar; ac_word=$2
3530 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3531 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3532 + if test "${ac_cv_prog_AR+set}" = set; then
3533 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3534 + else
3535 +  if test -n "$AR"; then
3536 +  ac_cv_prog_AR="$AR" # Let the user override the test.
3537 + else
3538 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3539 + for as_dir in $PATH
3540 + do
3541 +  IFS=$as_save_IFS
3542 +  test -z "$as_dir" && as_dir=.
3543 +  for ac_exec_ext in '' $ac_executable_extensions; do
3544 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3545 +    ac_cv_prog_AR="ar"
3546 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3547 +    break 2
3548 +  fi
3549 + done
3550 + done
3551 +
3552 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3553 + fi
3554 + fi
3555 + AR=$ac_cv_prog_AR
3556 + if test -n "$AR"; then
3557 +  echo "$as_me:$LINENO: result: $AR" >&5
3558 + echo "${ECHO_T}$AR" >&6
3559 + else
3560 +  echo "$as_me:$LINENO: result: no" >&5
3561 + echo "${ECHO_T}no" >&6
3562 + fi
3563 +
3564 + if test "$AR" = "NONE"; then
3565 +  cat >confcache <<\_ACEOF
3566 + # This file is a shell script that caches the results of configure
3567 + # tests run on this system so they can be shared between configure
3568 + # scripts and configure runs, see configure's option --config-cache.
3569 + # It is not useful on other systems.  If it contains results you don't
3570 + # want to keep, you may remove or edit it.
3571 + #
3572 + # config.status only pays attention to the cache file if you give it
3573 + # the --recheck option to rerun configure.
3574 + #
3575 + # `ac_cv_env_foo' variables (set or unset) will be overridden when
3576 + # loading this file, other *unset* `ac_cv_foo' will be assigned the
3577 + # following values.
3578 +
3579 + _ACEOF
3580 +
3581 + # The following way of writing the cache mishandles newlines in values,
3582 + # but we know of no workaround that is simple, portable, and efficient.
3583 + # So, don't put newlines in cache variables' values.
3584 + # Ultrix sh set writes to stderr and can't be redirected directly,
3585 + # and sets the high bit in the cache file unless we assign to the vars.
3586 + {
3587 +  (set) 2>&1 |
3588 +    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3589 +    *ac_space=\ *)
3590 +      # `set' does not quote correctly, so add quotes (double-quote
3591 +      # substitution turns \\\\ into \\, and sed turns \\ into \).
3592 +      sed -n \
3593 +        "s/'/'\\\\''/g;
3594 +          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3595 +      ;;
3596 +    *)
3597 +      # `set' quotes correctly as required by POSIX, so do not add quotes.
3598 +      sed -n \
3599 +        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3600 +      ;;
3601 +    esac;
3602 + } |
3603 +  sed '
3604 +     t clear
3605 +     : clear
3606 +     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3607 +     t end
3608 +     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3609 +     : end' >>confcache
3610 + if diff $cache_file confcache >/dev/null 2>&1; then :; else
3611 +  if test -w $cache_file; then
3612 +    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3613 +    cat confcache >$cache_file
3614 +  else
3615 +    echo "not updating unwritable cache $cache_file"
3616 +  fi
3617 + fi
3618 + rm -f confcache
3619 +  exit 1
3620 + fi
3621 + # Extract the first word of "ps", so it can be a program name with args.
3622 + set dummy ps; ac_word=$2
3623 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3624 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3625 + if test "${ac_cv_path_PS+set}" = set; then
3626 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3627 + else
3628 +  case $PS in
3629 +  [\\/]* | ?:[\\/]*)
3630 +  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3631 +  ;;
3632 +  *)
3633 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3634 + for as_dir in $PATH
3635 + do
3636 +  IFS=$as_save_IFS
3637 +  test -z "$as_dir" && as_dir=.
3638 +  for ac_exec_ext in '' $ac_executable_extensions; do
3639 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3640 +    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3641 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3642 +    break 2
3643 +  fi
3644 + done
3645 + done
3646 +
3647 +  ;;
3648 + esac
3649 + fi
3650 + PS=$ac_cv_path_PS
3651 +
3652 + if test -n "$PS"; then
3653 +  echo "$as_me:$LINENO: result: $PS" >&5
3654 + echo "${ECHO_T}$PS" >&6
3655 + else
3656 +  echo "$as_me:$LINENO: result: no" >&5
3657 + echo "${ECHO_T}no" >&6
3658 + fi
3659 +
3660 + echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3661 + echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3662 + if test "${ac_cv_prog_ps_syntax+set}" = set; then
3663 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3664 + else
3665 +
3666 +        if $PS ax -o rss > /dev/null 2>&1; then
3667 +                ac_cv_prog_ps_ax=yes
3668 +        else
3669 +                ac_cv_prog_ps_ax=no
3670 +        fi
3671 +        if $PS -ef -o rss > /dev/null 2>&1; then
3672 +                ac_cv_prog_ps_ef=yes
3673 +        else
3674 +                ac_cv_prog_ps_ef=no
3675 +        fi
3676 +        if test "$ac_cv_prog_ps_ax" = yes; then
3677 +                ac_cv_prog_ps_syntax=BSD
3678 +        else
3679 +                if test "$ac_cv_prog_ps_ef" = yes; then
3680 +                        ac_cv_prog_ps_syntax=POSIX
3681 +                else
3682 +                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3683 + echo "$as_me: error: Could not determine ps syntax" >&2;}
3684 +   { (exit 1); exit 1; }; }
3685 +                fi
3686 +        fi
3687 +
3688 + fi
3689 + echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3690 + echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3691 +
3692 + cat >>confdefs.h <<_ACEOF
3693 + #define PSCOMMAND $PS
3694 + _ACEOF
3695 +
3696 + if test "$ac_cv_prog_ps_syntax" = BSD; then
3697 +
3698 + cat >>confdefs.h <<\_ACEOF
3699 + #define PSTYPE_IS_BSD 1
3700 + _ACEOF
3701 +
3702 + else
3703 +   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3704 +
3705 + cat >>confdefs.h <<\_ACEOF
3706 + #define PSTYPE_IS_POSIX 1
3707 + _ACEOF
3708 +
3709 +   else
3710 +       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3711 + echo "$as_me: error: Unknown ps syntax type!" >&2;}
3712 +   { (exit 1); exit 1; }; }
3713 +   fi
3714 + fi
3715 +
3716 + ac_ext=${FC_SRCEXT-f}
3717 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3718 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3719 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3720 +
3721 +
3722 + echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3723 + echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3724 + if test "${ac_cv_fc_srcext_F90+set}" = set; then
3725 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3726 + else
3727 +  ac_ext=F90
3728 + ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3729 + FCFLAGS_SRCEXT=""
3730 + ac_cv_fc_srcext_F90=unknown
3731 + for ac_flag in none -qsuffix=f=F90 -Tf; do
3732 +  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3733 +  cat >conftest.$ac_ext <<_ACEOF
3734 +      program main
3735 +
3736 +      end
3737 + _ACEOF
3738 + rm -f conftest.$ac_objext
3739 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3740 +  (eval $ac_compile) 2>conftest.er1
3741 +  ac_status=$?
3742 +  grep -v '^ *+' conftest.er1 >conftest.err
3743 +  rm -f conftest.er1
3744 +  cat conftest.err >&5
3745 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3746 +  (exit $ac_status); } &&
3747 +         { ac_try='test -z "$ac_fc_werror_flag"
3748 +                         || test ! -s conftest.err'
3749 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3750 +  (eval $ac_try) 2>&5
3751 +  ac_status=$?
3752 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3753 +  (exit $ac_status); }; } &&
3754 +         { ac_try='test -s conftest.$ac_objext'
3755 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3756 +  (eval $ac_try) 2>&5
3757 +  ac_status=$?
3758 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3759 +  (exit $ac_status); }; }; then
3760 +  ac_cv_fc_srcext_F90=$ac_flag; break
3761 + else
3762 +  echo "$as_me: failed program was:" >&5
3763 + sed 's/^/| /' conftest.$ac_ext >&5
3764 +
3765 + fi
3766 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3767 + done
3768 + rm -f conftest.$ac_objext conftest.F90
3769 + FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3770 +
3771 + fi
3772 + echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3773 + echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3774 + if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3775 +  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3776 + echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3777 +   { (exit 1); exit 1; }; }
3778 + else
3779 +  FC_SRCEXT=F90
3780 +  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3781 +    FCFLAGS_SRCEXT=""
3782 +    FCFLAGS_F90=""
3783 +  else
3784 +    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3785 +    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3786 +  fi
3787 +
3788 +
3789 + fi
3790 +
3791 +
3792 +
3793 +
3794 +
3795 + # Try to determine native compiler flags that allow us to use F90 suffix
3796 + # for preprocessed f90 source.
3797 +
3798 + if test "$ac_test_PREPFLAG" != "set"; then
3799 +  PREPFLAG=""
3800 +  case "${host_cpu}-${host_os}" in
3801 +
3802 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3803 +                    PREPFLAG="-fpp1 "
3804 +                fi;;
3805 +  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3806 +                    PREPFLAG="-qsuffix=cpp=F90 "
3807 +                fi;;
3808 +  *darwin*)
3809 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3810 +                PREPFLAG="-qsuffix=cpp=F90 "
3811 +        fi;;
3812 +  esac
3813 +
3814 +  if test -z "$PREPFLAG"; then
3815 +        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3816 + echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3817 +        PREPFLAG=""
3818 +  fi
3819 +
3820 +  echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3821 + echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3822 +
3823 +
3824 +  ac_ext=${FC_SRCEXT-f}
3825 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3826 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3827 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3828 +
3829 +  ac_save_ext=$ac_ext
3830 +  ac_ext=F90
3831 +  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3832 +
3833 +  if test "$PREPFLAG"; then
3834 +  FCFLAGS_SRCEXT="${PREPFLAG}"
3835 + fi
3836 +
3837 +    cat >conftest.$ac_ext <<_ACEOF
3838 +
3839 +
3840 + program conftest
3841 +  integer :: i
3842 +  i = 1
3843 + end program conftest
3844 +
3845 + _ACEOF
3846 + rm -f conftest.$ac_objext
3847 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3848 +  (eval $ac_compile) 2>conftest.er1
3849 +  ac_status=$?
3850 +  grep -v '^ *+' conftest.er1 >conftest.err
3851 +  rm -f conftest.er1
3852 +  cat conftest.err >&5
3853 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3854 +  (exit $ac_status); } &&
3855 +         { ac_try='test -z "$ac_fc_werror_flag"
3856 +                         || test ! -s conftest.err'
3857 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3858 +  (eval $ac_try) 2>&5
3859 +  ac_status=$?
3860 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3861 +  (exit $ac_status); }; } &&
3862 +         { ac_try='test -s conftest.$ac_objext'
3863 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3864 +  (eval $ac_try) 2>&5
3865 +  ac_status=$?
3866 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3867 +  (exit $ac_status); }; }; then
3868 +  prepflagworks=1
3869 + else
3870 +  echo "$as_me: failed program was:" >&5
3871 + sed 's/^/| /' conftest.$ac_ext >&5
3872 +
3873 + prepflagworks=0
3874 + fi
3875 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3876 +
3877 +  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3878 +  ac_ext=$ac_save_ext
3879 +  ac_ext=${FC_SRCEXT-f}
3880 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3881 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3882 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3883 +
3884 +
3885 +  if test "$prepflagworks" = 1; then
3886 +    echo "$as_me:$LINENO: result: yes" >&5
3887 + echo "${ECHO_T}yes" >&6
3888 +    FCFLAGS_SRCEXT="${PREPFLAG}"
3889 +
3890 +  else
3891 +    echo "$as_me:$LINENO: result: no" >&5
3892 + echo "${ECHO_T}no" >&6
3893 +    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3894 + echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3895 +   { (exit 1); exit 1; }; }
3896 +  fi
3897 + fi
3898 +
3899 +
3900 +
3901 +
3902 +
3903 + # Try to determine native compiler flags that allow us to use F90 suffix
3904 + # for preprocessed f90 source with -D type defines
3905 +
3906 + if test "$ac_test_PREPDEFFLAG" != "set"; then
3907 +  PREPDEFFLAG=""
3908 +  case "${host_cpu}-${host_os}" in
3909 +
3910 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3911 +                    PREPDEFFLAG=" "
3912 +                fi;;
3913 +  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3914 +                    PREPDEFFLAG="-WF,"
3915 +                fi;;
3916 +  *darwin*)
3917 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3918 +                PREPDEFFLAG="-WF,"
3919 +        fi;;
3920 +  esac
3921 +
3922 +  if test -z "$PREPDEFFLAG"; then
3923 +        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3924 + echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3925 +        PREPDEFFLAG=" "
3926 +  fi
3927 +
3928 +  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3929 + echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3930 +
3931 +
3932 +  ac_ext=${FC_SRCEXT-f}
3933 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3934 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3935 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3936 +
3937 +  ac_save_ext=$ac_ext
3938 +  ac_ext=F90
3939 +  ac_save_FCFLAGS=$FCFLAGS
3940 +
3941 +  if test "$PREPDEFFLAG"; then
3942 +  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3943 + fi
3944 +
3945 +    cat >conftest.$ac_ext <<_ACEOF
3946 +
3947 +
3948 + program conftest
3949 +  integer :: i
3950 + #ifdef TEST
3951 +  i = 1
3952 + #else
3953 +  choke me
3954 + #endif
3955 + end program conftest
3956 +
3957 + _ACEOF
3958 + rm -f conftest.$ac_objext
3959 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3960 +  (eval $ac_compile) 2>conftest.er1
3961 +  ac_status=$?
3962 +  grep -v '^ *+' conftest.er1 >conftest.err
3963 +  rm -f conftest.er1
3964 +  cat conftest.err >&5
3965 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3966 +  (exit $ac_status); } &&
3967 +         { ac_try='test -z "$ac_fc_werror_flag"
3968 +                         || test ! -s conftest.err'
3969 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3970 +  (eval $ac_try) 2>&5
3971 +  ac_status=$?
3972 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3973 +  (exit $ac_status); }; } &&
3974 +         { ac_try='test -s conftest.$ac_objext'
3975 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3976 +  (eval $ac_try) 2>&5
3977 +  ac_status=$?
3978 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3979 +  (exit $ac_status); }; }; then
3980 +  prepdefflagworks=1
3981 + else
3982 +  echo "$as_me: failed program was:" >&5
3983 + sed 's/^/| /' conftest.$ac_ext >&5
3984 +
3985 + prepdefflagworks=0
3986 + fi
3987 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3988 +
3989 +  FCFLAGS=$ac_save_FCFLAGS
3990 +  ac_ext=$ac_save_ext
3991 +  ac_ext=${FC_SRCEXT-f}
3992 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3993 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3994 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3995 +
3996 +
3997 +  if test "$prepdefflagworks" = 1; then
3998 +    echo "$as_me:$LINENO: result: yes" >&5
3999 + echo "${ECHO_T}yes" >&6
4000 +
4001 +  else
4002 +    echo "$as_me:$LINENO: result: no" >&5
4003 + echo "${ECHO_T}no" >&6
4004 +    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
4005 + echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
4006 +   { (exit 1); exit 1; }; }
4007 +  fi
4008 + fi
4009 +
4010 + ac_ext=${FC_SRCEXT-f}
4011 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4012 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4013 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4014 + echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4015 + echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4016 + if test "${ac_cv_prog_fc_v+set}" = set; then
4017 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4018 + else
4019 +  cat >conftest.$ac_ext <<_ACEOF
4020 +      program main
4021 +
4022 +      end
4023 + _ACEOF
4024 + rm -f conftest.$ac_objext
4025 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4026 +  (eval $ac_compile) 2>conftest.er1
4027 +  ac_status=$?
4028 +  grep -v '^ *+' conftest.er1 >conftest.err
4029 +  rm -f conftest.er1
4030 +  cat conftest.err >&5
4031 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4032 +  (exit $ac_status); } &&
4033 +         { ac_try='test -z "$ac_fc_werror_flag"
4034 +                         || test ! -s conftest.err'
4035 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4036 +  (eval $ac_try) 2>&5
4037 +  ac_status=$?
4038 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4039 +  (exit $ac_status); }; } &&
4040 +         { ac_try='test -s conftest.$ac_objext'
4041 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4042 +  (eval $ac_try) 2>&5
4043 +  ac_status=$?
4044 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4045 +  (exit $ac_status); }; }; then
4046 +  ac_cv_prog_fc_v=
4047 + # Try some options frequently used verbose output
4048 + for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4049 +  cat >conftest.$ac_ext <<_ACEOF
4050 +      program main
4051 +
4052 +      end
4053 + _ACEOF
4054 +
4055 + # Compile and link our simple test program by passing a flag (argument
4056 + # 1 to this macro) to the Fortran compiler in order to get
4057 + # "verbose" output that we can then parse for the Fortran linker
4058 + # flags.
4059 + ac_save_FFLAGS=$FCFLAGS
4060 + FCFLAGS="$FCFLAGS $ac_verb"
4061 + (eval echo $as_me:4061: \"$ac_link\") >&5
4062 + ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4063 + echo "$ac_fc_v_output" >&5
4064 + FCFLAGS=$ac_save_FFLAGS
4065 +
4066 + rm -f conftest*
4067 +
4068 + # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4069 + # /foo, /bar, and /baz are search directories for the Fortran linker.
4070 + # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4071 + ac_fc_v_output="`echo $ac_fc_v_output |
4072 +        grep 'LPATH is:' |
4073 +        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4074 +
4075 + case $ac_fc_v_output in
4076 +  # If we are using xlf then replace all the commas with spaces.
4077 +  *xlfentry*)
4078 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4079 +
4080 +  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4081 +  # $LIBS confuse us, and the libraries appear later in the output anyway).
4082 +  *mGLOB_options_string*)
4083 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4084 +
4085 +  # If we are using Cray Fortran then delete quotes.
4086 +  # Use "\"" instead of '"' for font-lock-mode.
4087 +  # FIXME: a more general fix for quoted arguments with spaces?
4088 +  *cft90*)
4089 +    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4090 + esac
4091 +
4092 +
4093    # look for -l* and *.a constructs in the output
4094 <  for ac_arg in $ac_f90_v_output; do
4094 >  for ac_arg in $ac_fc_v_output; do
4095       case $ac_arg in
4096          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4097 <          ac_cv_prog_f90_v=$ac_verb
4097 >          ac_cv_prog_fc_v=$ac_verb
4098            break 2 ;;
4099       esac
4100    done
4101   done
4102 < if test -z "$ac_cv_prog_f90_v"; then
4103 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4104 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4102 > if test -z "$ac_cv_prog_fc_v"; then
4103 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4104 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4105   fi
4106   else
4107    echo "$as_me: failed program was:" >&5
# Line 3414 | Line 4110 | fi
4110   { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4111   echo "$as_me: WARNING: compilation failed" >&2;}
4112   fi
4113 < rm -f conftest.$ac_objext conftest.$ac_ext
4113 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4114  
4115   fi
4116 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4117 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4118 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4119 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4120 < if test "${ac_cv_flibs+set}" = set; then
4116 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4117 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4118 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4119 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4120 > if test "${ac_cv_fc_libs+set}" = set; then
4121    echo $ECHO_N "(cached) $ECHO_C" >&6
4122   else
4123 <  if test "x$F90LIBS" != "x"; then
4124 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4123 >  if test "x$FCLIBS" != "x"; then
4124 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4125   else
4126  
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
4127   cat >conftest.$ac_ext <<_ACEOF
4128 +      program main
4129  
4130 < program main
3439 <
3440 <
3441 < end program main
3442 <
4130 >      end
4131   _ACEOF
4132  
4133   # Compile and link our simple test program by passing a flag (argument
4134 < # 1 to this macro) to the Fortran 90 compiler in order to get
4135 < # "verbose" output that we can then parse for the Fortran 90 linker
4134 > # 1 to this macro) to the Fortran compiler in order to get
4135 > # "verbose" output that we can then parse for the Fortran linker
4136   # flags.
4137 < ac_save_F90FLAGS=$F90FLAGS
4138 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4137 > ac_save_FFLAGS=$FCFLAGS
4138 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4139 > (eval echo $as_me:4139: \"$ac_link\") >&5
4140 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4141 > echo "$ac_fc_v_output" >&5
4142 > FCFLAGS=$ac_save_FFLAGS
4143  
4144 < (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
4144 > rm -f conftest*
4145  
4146 < rm -f conftest.*
4147 < ac_ext=f90
4148 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4149 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4150 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4146 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4147 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4148 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4149 > ac_fc_v_output="`echo $ac_fc_v_output |
4150 >        grep 'LPATH is:' |
4151 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4152  
4153 < # If we are using xlf then replace all the commas with spaces.
4154 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4155 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4156 < fi
4153 > case $ac_fc_v_output in
4154 >  # If we are using xlf then replace all the commas with spaces.
4155 >  *xlfentry*)
4156 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4157  
4158 < # If we are using Cray Fortran then delete quotes.
4159 < # Use "\"" instead of '"' for font-lock-mode.
4160 < # FIXME: a more general fix for quoted arguments with spaces?
4161 < 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
4158 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4159 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4160 >  *mGLOB_options_string*)
4161 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4162  
4163 < ac_cv_f90libs=
4163 >  # If we are using Cray Fortran then delete quotes.
4164 >  # Use "\"" instead of '"' for font-lock-mode.
4165 >  # FIXME: a more general fix for quoted arguments with spaces?
4166 >  *cft90*)
4167 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4168 > esac
4169  
4170 +
4171 +
4172 + ac_cv_fc_libs=
4173 +
4174   # Save positional arguments (if any)
4175   ac_save_positional="$@"
4176  
4177 < set X $ac_f90_v_output
4177 > set X $ac_fc_v_output
4178   while test $# != 1; do
4179    shift
4180    ac_arg=$1
4181    case $ac_arg in
4182          [\\/]*.a | ?:[\\/]*.a)
4183              ac_exists=false
4184 <  for ac_i in $ac_cv_f90libs; do
4184 >  for ac_i in $ac_cv_fc_libs; do
4185      if test x"$ac_arg" = x"$ac_i"; then
4186        ac_exists=true
4187        break
# Line 3494 | Line 4191 | else
4191    if test x"$ac_exists" = xtrue; then
4192    :
4193   else
4194 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4194 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4195   fi
4196  
4197            ;;
4198          -bI:*)
4199              ac_exists=false
4200 <  for ac_i in $ac_cv_f90libs; do
4200 >  for ac_i in $ac_cv_fc_libs; do
4201      if test x"$ac_arg" = x"$ac_i"; then
4202        ac_exists=true
4203        break
# Line 3512 | Line 4209 | else
4209   else
4210    if test "$ac_compiler_gnu" = yes; then
4211    for ac_link_opt in $ac_arg; do
4212 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4212 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4213    done
4214   else
4215 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4215 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4216   fi
4217   fi
4218  
4219            ;;
4220            # Ignore these flags.
4221 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4221 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4222            ;;
4223          -lkernel32)
4224 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4224 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4225            ;;
4226          -[LRuY])
4227            # These flags, when seen by themselves, take an argument.
4228            # We remove the space between option and argument and re-iterate
4229            # unless we find an empty arg or a new option (starting with -)
4230            case $2 in
4231 <             "" | -*);;
4232 <             *)
4231 >             "" | -*);;
4232 >             *)
4233                  ac_arg="$ac_arg$2"
3537
4234                  shift; shift
4235                  set X $ac_arg "$@"
4236                  ;;
# Line 3543 | Line 4239 | fi
4239          -YP,*)
4240            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4241                ac_exists=false
4242 <  for ac_i in $ac_cv_f90libs; do
4242 >  for ac_i in $ac_cv_fc_libs; do
4243      if test x"$ac_j" = x"$ac_i"; then
4244        ac_exists=true
4245        break
# Line 3554 | Line 4250 | else
4250    :
4251   else
4252    ac_arg="$ac_arg $ac_j"
4253 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4253 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4254   fi
4255  
4256            done
4257            ;;
4258          -[lLR]*)
4259              ac_exists=false
4260 <  for ac_i in $ac_cv_f90libs; do
4260 >  for ac_i in $ac_cv_fc_libs; do
4261      if test x"$ac_arg" = x"$ac_i"; then
4262        ac_exists=true
4263        break
# Line 3571 | Line 4267 | else
4267    if test x"$ac_exists" = xtrue; then
4268    :
4269   else
4270 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4270 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4271   fi
4272  
4273            ;;
# Line 3586 | Line 4282 | case `(uname -sr) 2>/dev/null` in
4282   # must begin with a "/").
4283   case `(uname -sr) 2>/dev/null` in
4284     "SunOS 5"*)
4285 <      ac_ld_run_path=`echo $ac_f90_v_output |
4285 >      ac_ld_run_path=`echo $ac_fc_v_output |
4286                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4287        test "x$ac_ld_run_path" != x &&
3592
4288          if test "$ac_compiler_gnu" = yes; then
4289    for ac_link_opt in $ac_ld_run_path; do
4290 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4290 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4291    done
4292   else
4293 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4293 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4294   fi
4295        ;;
4296   esac
4297 < fi # test "x$F90LIBS" = "x"
4297 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4298  
4299   fi
4300 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4301 < echo "${ECHO_T}$ac_cv_flibs" >&6
4302 < F90LIBS="$ac_cv_f90libs"
4300 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4301 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4302 > FCLIBS="$ac_cv_fc_libs"
4303  
4304 < ac_ext=f90
4305 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4306 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4307 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4308 <
4309 <
4310 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4311 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4312 < if test "${ac_cv_f90_mangling+set}" = set; then
4313 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4314 < else
4315 <  ac_ext=f90
4316 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4317 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4318 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4319 < cat >conftest.$ac_ext <<_ACEOF
4320 < subroutine foobar()
4321 < return
4322 < end
4323 < subroutine foo_bar()
4324 < return
4325 < end
4326 < _ACEOF
4327 < rm -f conftest.$ac_objext
4328 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4329 <  (eval $ac_compile) 2>&5
4330 <  ac_status=$?
4331 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4332 <  (exit $ac_status); } &&
4333 <         { ac_try='test -s conftest.$ac_objext'
4334 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4335 <  (eval $ac_try) 2>&5
4336 <  ac_status=$?
4337 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4338 <  (exit $ac_status); }; }; then
4339 <  mv conftest.$ac_objext cf90_test.$ac_objext
4340 <
4341 <  ac_ext=c
4342 < ac_cpp='$CPP $CPPFLAGS'
4343 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4344 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4345 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4346 <
4347 <  ac_save_LIBS=$LIBS
4348 <  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
4349 <
4350 <  ac_success=no
4351 <  for ac_foobar in foobar FOOBAR; do
4352 <    for ac_underscore in "" "_"; do
4353 <      ac_func="$ac_foobar$ac_underscore"
4354 <      cat >conftest.$ac_ext <<_ACEOF
4355 < #line $LINENO "configure"
4356 < /* confdefs.h.  */
4357 < _ACEOF
4358 < cat confdefs.h >>conftest.$ac_ext
4359 < cat >>conftest.$ac_ext <<_ACEOF
4360 < /* end confdefs.h.  */
4361 <
4362 < /* Override any gcc2 internal prototype to avoid an error.  */
4363 < #ifdef __cplusplus
4364 < extern "C"
4365 < #endif
4366 < /* We use char because int might match the return type of a gcc2
4367 <   builtin and then its argument prototype would still apply.  */
4368 < char $ac_func ();
4369 < int
4370 < main ()
4371 < {
4372 < $ac_func ();
4373 <  ;
4374 <  return 0;
4375 < }
4376 < _ACEOF
4377 < rm -f conftest.$ac_objext conftest$ac_exeext
4378 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4379 <  (eval $ac_link) 2>&5
4380 <  ac_status=$?
4381 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4382 <  (exit $ac_status); } &&
4383 <         { ac_try='test -s conftest$ac_exeext'
4384 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4385 <  (eval $ac_try) 2>&5
4386 <  ac_status=$?
4387 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4388 <  (exit $ac_status); }; }; then
4389 <  ac_success=yes; break 2
4390 < else
4391 <  echo "$as_me: failed program was:" >&5
4392 < sed 's/^/| /' conftest.$ac_ext >&5
4393 <
4394 < fi
4395 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
4396 <    done
4397 <  done
4398 <
4399 <  if test "$ac_success" = "yes"; then
4400 <     case $ac_foobar in
4401 <        foobar)
4402 <           ac_case=lower
4403 <           ac_foo_bar=foo_bar
4404 <           ;;
4405 <        FOOBAR)
4406 <           ac_case=upper
4407 <           ac_foo_bar=FOO_BAR
4408 <           ;;
4409 <     esac
4410 <
4411 <     ac_success_extra=no
4412 <     for ac_extra in "" "_"; do
4413 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4414 <
4415 <        cat >conftest.$ac_ext <<_ACEOF
4416 < #line $LINENO "configure"
4417 < /* confdefs.h.  */
4418 < _ACEOF
4419 < cat confdefs.h >>conftest.$ac_ext
4420 < cat >>conftest.$ac_ext <<_ACEOF
4421 < /* end confdefs.h.  */
4422 <
4423 < /* Override any gcc2 internal prototype to avoid an error.  */
4424 < #ifdef __cplusplus
4425 < extern "C"
4426 < #endif
4427 < /* We use char because int might match the return type of a gcc2
4428 <   builtin and then its argument prototype would still apply.  */
4429 < char $ac_func ();
4430 < int
4431 < main ()
4432 < {
4433 < $ac_func ();
4434 <  ;
4435 <  return 0;
4436 < }
4437 < _ACEOF
4438 < rm -f conftest.$ac_objext conftest$ac_exeext
4439 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4440 <  (eval $ac_link) 2>&5
4441 <  ac_status=$?
4442 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4443 <  (exit $ac_status); } &&
4444 <         { ac_try='test -s conftest$ac_exeext'
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); }; }; then
4450 <  ac_success_extra=yes; break
4451 < else
4452 <  echo "$as_me: failed program was:" >&5
4453 < sed 's/^/| /' conftest.$ac_ext >&5
4454 <
4455 < fi
4456 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
4457 <     done
4458 <
4459 <     if test "$ac_success_extra" = "yes"; then
4460 <        ac_cv_f90_mangling="$ac_case case"
4461 <        if test -z "$ac_underscore"; then
4462 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4463 <        else
4464 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4465 <
4466 <        fi
4467 <        if test -z "$ac_extra"; then
4468 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4469 <        else
4470 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4471 <        fi
4472 <      else
4473 <        ac_cv_f90_mangling="unknown"
4474 <      fi
4475 <  else
4476 <     ac_cv_f90_mangling="unknown"
4477 <
4478 <  fi
4479 <
4480 <  LIBS=$ac_save_LIBS
4481 <  ac_ext=f90
4482 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4483 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4484 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4485 <  rm -f cf90_test* conftest*
4486 < else
4487 <  echo "$as_me: failed program was:" >&5
4488 < sed 's/^/| /' conftest.$ac_ext >&5
4489 <
4490 < fi
4491 < rm -f conftest.$ac_objext conftest.$ac_ext
4492 < ac_ext=f90
4493 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4494 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4495 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4496 <
4497 < fi
4498 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4499 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4500 <
4501 <
4502 <
4503 < case $ac_cv_f90_mangling in
4504 <  "lower case, no underscore, no extra underscore")
4505 <          cat >>confdefs.h <<\_ACEOF
4506 < #define F90_FUNC(name,NAME) name
4507 < _ACEOF
4508 <
4509 <          cat >>confdefs.h <<\_ACEOF
4510 < #define F90_FUNC_(name,NAME) name
4511 < _ACEOF
4512 < ;;
4513 <  "lower case, no underscore, extra underscore")
4514 <          cat >>confdefs.h <<\_ACEOF
4515 < #define F90_FUNC(name,NAME) name
4516 < _ACEOF
4517 <
4518 <          cat >>confdefs.h <<\_ACEOF
4519 < #define F90_FUNC_(name,NAME) name ## _
4520 < _ACEOF
4521 < ;;
4522 <  "lower case, underscore, no extra underscore")
4523 <          cat >>confdefs.h <<\_ACEOF
4524 < #define F90_FUNC(name,NAME) name ## _
4525 < _ACEOF
4526 <
4527 <          cat >>confdefs.h <<\_ACEOF
4528 < #define F90_FUNC_(name,NAME) name ## _
4529 < _ACEOF
4530 < ;;
4531 <  "lower case, underscore, extra underscore")
4532 <          cat >>confdefs.h <<\_ACEOF
4533 < #define F90_FUNC(name,NAME) name ## _
4534 < _ACEOF
4535 <
4536 <          cat >>confdefs.h <<\_ACEOF
4537 < #define F90_FUNC_(name,NAME) name ## __
4538 < _ACEOF
4539 < ;;
4540 <  "upper case, no underscore, no extra underscore")
4541 <          cat >>confdefs.h <<\_ACEOF
4542 < #define F90_FUNC(name,NAME) NAME
4543 < _ACEOF
4544 <
4545 <          cat >>confdefs.h <<\_ACEOF
4546 < #define F90_FUNC_(name,NAME) NAME
4547 < _ACEOF
4548 < ;;
4549 <  "upper case, no underscore, extra underscore")
4550 <          cat >>confdefs.h <<\_ACEOF
4551 < #define F90_FUNC(name,NAME) NAME
4552 < _ACEOF
4553 <
4554 <          cat >>confdefs.h <<\_ACEOF
4555 < #define F90_FUNC_(name,NAME) NAME ## _
4556 < _ACEOF
4557 < ;;
4558 <  "upper case, underscore, no extra underscore")
4559 <          cat >>confdefs.h <<\_ACEOF
4560 < #define F90_FUNC(name,NAME) NAME ## _
4561 < _ACEOF
4562 <
4563 <          cat >>confdefs.h <<\_ACEOF
4564 < #define F90_FUNC_(name,NAME) NAME ## _
4565 < _ACEOF
4566 < ;;
4567 <  "upper case, underscore, extra underscore")
4568 <          cat >>confdefs.h <<\_ACEOF
4569 < #define F90_FUNC(name,NAME) NAME ## _
4570 < _ACEOF
4571 <
4572 <          cat >>confdefs.h <<\_ACEOF
4573 < #define F90_FUNC_(name,NAME) NAME ## __
4574 < _ACEOF
4575 < ;;
4576 <  *)
4577 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4578 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4579 <          ;;
4580 < esac
4581 <
4582 <
4583 <
4584 <
4585 <
4586 < echo "$as_me:$LINENO: checking for module suffix" >&5
4587 < echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
4588 < rm -f conftest*
4589 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4590 < rm -f work*
4591 < cat >conftest.f90 <<EOF
4592 <        module conftest
4593 <        integer n
4594 <        parameter (n=1)
4595 <        end module conftest
4596 < EOF
4597 < # SGI and absoft compilers generates module name in upper case!
4598 < testname="conftest"
4599 < modcase="lower"
4600 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4601 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
4602 <    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
4603 <    if test -z "$MOD" ; then
4604 <        MOD=`ls CONFTEST* 2>/dev/null \
4605 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
4606 <        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
4607 <        if test -n "$MOD" ; then
4608 <            testname="CONFTEST"
4609 <            modcase="upper"
4610 <        fi
4611 <    fi
4612 <    if test -z "$MOD" ; then
4613 <        echo "$as_me:$LINENO: result: unknown" >&5
4614 < echo "${ECHO_T}unknown" >&6
4615 <        # Use mod if we can't figure it out
4616 <        MOD="mod"
4617 <    else
4618 <        echo "$as_me:$LINENO: result: $MOD" >&5
4619 < echo "${ECHO_T}$MOD" >&6
4620 <    fi
4621 <    if test -s work.pcl ; then
4622 <        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
4623 < echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
4624 <    fi
4625 < else
4626 <    echo "$as_me:$LINENO: result: unknown" >&5
4627 < echo "${ECHO_T}unknown" >&6
4628 < fi
4629 <
4630 <
4631 <
4632 <
4633 <
4634 < # Check for module include path (some use -I, some (Solaris) use -M, some
4635 < # (absoft) use -p).
4636 < # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
4637 < # specified, work.pcl and work.pc are created.  However, if you specify
4638 < # a file, it must contain a the name of a file ending in .pc .  Ugh!
4639 < # Use the module made above
4640 < echo "$as_me:$LINENO: checking for module directory path flag" >&5
4641 < echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
4642 < rm -f conftest*
4643 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4644 < rm -f work*
4645 < cat >conftest.f90 <<EOF
4646 <        module conftest
4647 <        integer n
4648 <        parameter (n=1)
4649 <        end module conftest
4650 < EOF
4651 < # SGI and absoft compilers generates module name in upper case!
4652 < testname="conftest"
4653 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4654 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
4655 <   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
4656 <   if test -n "$mod" ; then
4657 <      testname="CONFTEST"
4658 <   fi
4659 <   madedir=0
4660 <   if test ! -d conf ; then mkdir conf ; madedir=1; fi
4661 <   cp $testname.$MOD conf
4662 <   rm -f conftest* CONFTEST*
4663 <   cat >conftest1.f90 <<EOF
4664 <        program main
4665 <        use conftest
4666 <        print *, n
4667 <        end
4668 < EOF
4669 <   F90_WORK_FILES_ARG=""
4670 <   F90MODINCSPEC=""
4671 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
4672 <       MODDIRFLAG="-I"
4673 <       F90MODINCSPEC="-I<dir>"
4674 <       echo "$as_me:$LINENO: result: -I" >&5
4675 < echo "${ECHO_T}-I" >&6
4676 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
4677 <       MODDIRFLAG="-M"
4678 <       F90MODINCSPEC="-M<dir>"
4679 <       echo "$as_me:$LINENO: result: -M" >&5
4680 < echo "${ECHO_T}-M" >&6
4681 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
4682 <       MODDIRFLAG="-p"
4683 <       F90MODINCSPEC="-p<dir>"
4684 <       echo "$as_me:$LINENO: result: -p" >&5
4685 < echo "${ECHO_T}-p" >&6
4686 <   elif test -s work.pc ; then
4687 <        cp work.pc conf/mpimod.pc
4688 <        echo "mpimod.pc" > conf/mpimod.pcl
4689 <        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
4690 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
4691 <            MODDIRFLAG='-cl,mpimod.pcl'
4692 <            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
4693 < echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
4694 <            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
4695 <            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
4696 <
4697 <        else
4698 <            # The version of the Intel compiler that I have refuses to let
4699 <            # you put the "work catalog" list anywhere but the current
4700 <            # directory. For example, you cannot in
4701 <         :
4702 <        fi
4703 <   fi
4704 <   if test -z "MODDIRFLAG" ; then
4705 <       echo "$as_me:$LINENO: result: unknown" >&5
4706 < echo "${ECHO_T}unknown" >&6
4707 <   fi
4708 <
4709 <
4710 <   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
4711 <   if test $madedir = 1 ; then rmdir conf ; fi
4712 < fi
4713 <
4714 <
4715 < echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
4716 < echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
4717 < if test "${ac_cv_f90_module_names+set}" = set; then
4718 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4719 < else
4720 <  ac_ext=f90
4721 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4722 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4723 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4724 <
4725 < # carry out the test in a new directory, so that we don't miss anything
4726 < mkdir conftest
4727 < cd conftest
4728 < cat >conftest.$ac_ext <<_ACEOF
4729 < MODULE Bar
4730 < END MODULE Bar
4731 < _ACEOF
4732 < rm -f conftest.$ac_objext
4733 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4734 <  (eval $ac_compile) 2>&5
4735 <  ac_status=$?
4736 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4737 <  (exit $ac_status); } &&
4738 <         { ac_try='test -s conftest.$ac_objext'
4739 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4740 <  (eval $ac_try) 2>&5
4741 <  ac_status=$?
4742 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4743 <  (exit $ac_status); }; }; then
4744 <  ac_cv_f90_module_names=
4745 < ac_file_list=*
4746 < for ac_file in $ac_file_list; do
4747 <   case $ac_file in
4748 <      # don't care for original source and object files
4749 <      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
4750 <          :
4751 <          ;;
4752 <      # look for new files derived from the file name
4753 <      *conftest*)
4754 <          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
4755 <            ac_exists=false
4756 <  for ac_i in $ac_cv_f90_module_names; do
4757 <    if test x"$ac_pat" = x"$ac_i"; then
4758 <      ac_exists=true
4759 <      break
4760 <    fi
4761 <  done
4762 <
4763 <  if test x"$ac_exists" = xtrue; then
4764 <  :
4765 < else
4766 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4767 < fi
4768 <
4769 <          ;;
4770 <      # look for new files derived from the module name,
4771 <      # with different case translation schemes
4772 <      *Bar*)
4773 <          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
4774 <            ac_exists=false
4775 <  for ac_i in $ac_cv_f90_module_names; do
4776 <    if test x"$ac_pat" = x"$ac_i"; then
4777 <      ac_exists=true
4778 <      break
4779 <    fi
4780 <  done
4781 <
4782 <  if test x"$ac_exists" = xtrue; then
4783 <  :
4784 < else
4785 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4786 < fi
4787 <
4788 <          ;;
4789 <      *bar*)
4790 <          ac_pat=`echo $ac_file | sed s/bar/%module%/`
4791 <            ac_exists=false
4792 <  for ac_i in $ac_cv_f90_module_names; do
4793 <    if test x"$ac_pat" = x"$ac_i"; then
4794 <      ac_exists=true
4795 <      break
4796 <    fi
4797 <  done
4798 <
4799 <  if test x"$ac_exists" = xtrue; then
4800 <  :
4801 < else
4802 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4803 < fi
4804 <
4805 <          ;;
4806 <      *BAR*)
4807 <          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
4808 <            ac_exists=false
4809 <  for ac_i in $ac_cv_f90_module_names; do
4810 <    if test x"$ac_pat" = x"$ac_i"; then
4811 <      ac_exists=true
4812 <      break
4813 <    fi
4814 <  done
4815 <
4816 <  if test x"$ac_exists" = xtrue; then
4817 <  :
4818 < else
4819 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4820 < fi
4821 <
4822 <          ;;
4823 <       # Other files - we have no idea how they are generated
4824 <       *)
4825 <          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
4826 < echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
4827 <          ;;
4828 <   esac
4829 < done
4830 < if test "x$ac_cv_f90_module_names" = "x"; then
4831 <  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4832 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4833 < fi
4834 <
4835 < else
4836 <  echo "$as_me: failed program was:" >&5
4837 < sed 's/^/| /' conftest.$ac_ext >&5
4838 <
4839 < ac_cv_f90_module_names=
4840 < { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4841 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4842 < fi
4843 < rm -f conftest.$ac_objext conftest.$ac_ext
4844 < cd ..
4845 < # cleanup
4846 < rm -rf conftest
4847 < ac_ext=f90
4848 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4849 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4850 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4851 <
4852 < fi
4853 < echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
4854 < echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
4855 <
4856 < # We now generate a shell script that will help us to figure out the correct
4857 < # module file names, using the value of ac_cv_f90_module_names
4858 <
4859 < echo "Generating shell script modnam"
4860 <
4861 < cat > scripts/modnam << EOF
4862 < #! /bin/sh
4863 < # This script is auto-generated by configure
4864 < #
4865 < usage="\\
4866 < Usage: \$0 [FILES]
4867 <
4868 < [FILES] are Fortran 90 source files.
4869 < The output is a list of module file names that the Fortran 90 compiler
4870 < generates when compiling [FILES]."
4871 <
4872 < list=
4873 < empty=
4874 <
4875 < if test \$# -eq 0; then
4876 <   echo "\$usage"; exit 0
4877 < fi
4878 <
4879 < while test \$# != 0; do
4880 <
4881 <  file=\$1
4882 <  shift
4883 <
4884 < # strip suffix
4885 <  base=\`echo \$file | sed 's/[.][^.]*$//'\`
4886 <
4887 <  test ! -f \$file && continue
4888 <
4889 < # Look for module definitions and transform them to upper / lower case
4890 <  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/'\`
4891 <  upper=\`echo \$mods | tr a-z A-Z\`
4892 <  lower=\`echo \$mods | tr A-Z a-z\`
4893 <
4894 < # Here, the patterns for generating module file names were inserted by configure
4895 <  for trans in $ac_cv_f90_module_names; do
4896 <
4897 <    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
4898 <    var=empty
4899 <    case \$pat in
4900 <       %MODULE%)
4901 <          var=upper ;;
4902 <       %Module%)
4903 <          var=mods ;;
4904 <       %module%)
4905 <          var=lower ;;
4906 <       %FILE%)
4907 <          test -n "\$mods" && var=base ;;
4908 <    esac
4909 <    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
4910 <    list="\$list \$new"
4911 <  done
4912 < done
4913 <
4914 < echo \$list
4915 < # end of configure-generated script
4916 < EOF
4917 < chmod 755 scripts/modnam
4918 <
4919 < pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
4920 < F90_MODULE_NAMES=empty
4921 < case $pat in
4922 <       %MODULE%)
4923 <          F90_MODULE_NAMES=UPPER ;;
4924 <       %Module%)
4925 <          F90_MODULE_NAMES=Mixed ;;
4926 <       %module%)
4927 <          F90_MODULE_NAMES=lower ;;
4928 <       *)
4929 <          F90_MODULE_NAMES=unknown ;;
4930 < esac
4931 <
4932 < ac_ext=c
4933 < ac_cpp='$CPP $CPPFLAGS'
4934 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4935 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4936 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4937 <
4938 <
4939 < ac_ext=c
4940 < ac_cpp='$CPP $CPPFLAGS'
4941 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4942 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4943 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4944 <
4945 < ac_ext=c
4946 < ac_cpp='$CPP $CPPFLAGS'
4947 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4948 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4949 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4950 < echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4951 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4952 < # On Suns, sometimes $CPP names a directory.
4953 < if test -n "$CPP" && test -d "$CPP"; then
4954 <  CPP=
4955 < fi
4956 < if test -z "$CPP"; then
4957 <  if test "${ac_cv_prog_CPP+set}" = set; then
4958 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4959 < else
4960 <      # Double quotes because CPP needs to be expanded
4961 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
4962 <    do
4963 <      ac_preproc_ok=false
4964 < for ac_c_preproc_warn_flag in '' yes
4304 >
4305 > ac_ext=${FC_SRCEXT-f}
4306 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4307 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4308 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4309 >
4310 >
4311 > ac_ext=${FC_SRCEXT-f}
4312 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4313 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4314 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4315 >
4316 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4317 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4318 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4319 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4320 > else
4321 >  ac_fc_dm_save_LIBS=$LIBS
4322 > LIBS="$LIBS $FCLIBS"
4323 > ac_fortran_dm_var=FC_DUMMY_MAIN
4324 > ac_ext=c
4325 > ac_cpp='$CPP $CPPFLAGS'
4326 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4327 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4328 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4329 >
4330 > # First, try linking without a dummy main:
4331 > cat >conftest.$ac_ext <<_ACEOF
4332 > /* confdefs.h.  */
4333 > _ACEOF
4334 > cat confdefs.h >>conftest.$ac_ext
4335 > cat >>conftest.$ac_ext <<_ACEOF
4336 > /* end confdefs.h.  */
4337 >
4338 > #ifdef FC_DUMMY_MAIN
4339 > #ifndef FC_DUMMY_MAIN_EQ_F77
4340 > #  ifdef __cplusplus
4341 >     extern "C"
4342 > #  endif
4343 >   int FC_DUMMY_MAIN() { return 1; }
4344 > #endif
4345 > #endif
4346 > int
4347 > main ()
4348 > {
4349 >
4350 >  ;
4351 >  return 0;
4352 > }
4353 > _ACEOF
4354 > rm -f conftest.$ac_objext conftest$ac_exeext
4355 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4356 >  (eval $ac_link) 2>conftest.er1
4357 >  ac_status=$?
4358 >  grep -v '^ *+' conftest.er1 >conftest.err
4359 >  rm -f conftest.er1
4360 >  cat conftest.err >&5
4361 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4362 >  (exit $ac_status); } &&
4363 >         { ac_try='test -z "$ac_c_werror_flag"
4364 >                         || test ! -s conftest.err'
4365 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4366 >  (eval $ac_try) 2>&5
4367 >  ac_status=$?
4368 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4369 >  (exit $ac_status); }; } &&
4370 >         { ac_try='test -s conftest$ac_exeext'
4371 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4372 >  (eval $ac_try) 2>&5
4373 >  ac_status=$?
4374 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4375 >  (exit $ac_status); }; }; then
4376 >  ac_cv_fortran_dummy_main=none
4377 > else
4378 >  echo "$as_me: failed program was:" >&5
4379 > sed 's/^/| /' conftest.$ac_ext >&5
4380 >
4381 > ac_cv_fortran_dummy_main=unknown
4382 > fi
4383 > rm -f conftest.err conftest.$ac_objext \
4384 >      conftest$ac_exeext conftest.$ac_ext
4385 >
4386 > if test $ac_cv_fortran_dummy_main = unknown; then
4387 >   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4388 >     cat >conftest.$ac_ext <<_ACEOF
4389 > /* confdefs.h.  */
4390 > _ACEOF
4391 > cat confdefs.h >>conftest.$ac_ext
4392 > cat >>conftest.$ac_ext <<_ACEOF
4393 > /* end confdefs.h.  */
4394 > #define $ac_fortran_dm_var $ac_func
4395 > #ifdef FC_DUMMY_MAIN
4396 > #ifndef FC_DUMMY_MAIN_EQ_F77
4397 > #  ifdef __cplusplus
4398 >     extern "C"
4399 > #  endif
4400 >   int FC_DUMMY_MAIN() { return 1; }
4401 > #endif
4402 > #endif
4403 > int
4404 > main ()
4405 > {
4406 >
4407 >  ;
4408 >  return 0;
4409 > }
4410 > _ACEOF
4411 > rm -f conftest.$ac_objext conftest$ac_exeext
4412 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4413 >  (eval $ac_link) 2>conftest.er1
4414 >  ac_status=$?
4415 >  grep -v '^ *+' conftest.er1 >conftest.err
4416 >  rm -f conftest.er1
4417 >  cat conftest.err >&5
4418 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4419 >  (exit $ac_status); } &&
4420 >         { ac_try='test -z "$ac_c_werror_flag"
4421 >                         || test ! -s conftest.err'
4422 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4423 >  (eval $ac_try) 2>&5
4424 >  ac_status=$?
4425 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4426 >  (exit $ac_status); }; } &&
4427 >         { ac_try='test -s conftest$ac_exeext'
4428 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4429 >  (eval $ac_try) 2>&5
4430 >  ac_status=$?
4431 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4432 >  (exit $ac_status); }; }; then
4433 >  ac_cv_fortran_dummy_main=$ac_func; break
4434 > else
4435 >  echo "$as_me: failed program was:" >&5
4436 > sed 's/^/| /' conftest.$ac_ext >&5
4437 >
4438 > fi
4439 > rm -f conftest.err conftest.$ac_objext \
4440 >      conftest$ac_exeext conftest.$ac_ext
4441 >   done
4442 > fi
4443 > ac_ext=${FC_SRCEXT-f}
4444 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4445 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4446 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4447 > ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4448 > rm -f conftest*
4449 > LIBS=$ac_fc_dm_save_LIBS
4450 >
4451 > fi
4452 > echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4453 > echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4454 > FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4455 > if test "$FC_DUMMY_MAIN" != unknown; then
4456 >  if test $FC_DUMMY_MAIN != none; then
4457 >
4458 > cat >>confdefs.h <<_ACEOF
4459 > #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4460 > _ACEOF
4461 >
4462 >  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4463 >
4464 > cat >>confdefs.h <<\_ACEOF
4465 > #define FC_DUMMY_MAIN_EQ_F77 1
4466 > _ACEOF
4467 >
4468 >  fi
4469 > fi
4470 > else
4471 >  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4472 > See \`config.log' for more details." >&5
4473 > echo "$as_me: error: linking to Fortran libraries from C fails
4474 > See \`config.log' for more details." >&2;}
4475 >   { (exit 1); exit 1; }; }
4476 > fi
4477 >
4478 >
4479 > ac_ext=${FC_SRCEXT-f}
4480 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4481 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4482 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4483 >
4484 > ac_ext=${FC_SRCEXT-f}
4485 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4486 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4487 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4488 > echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4489 > echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4490 > if test "${ac_cv_fc_mangling+set}" = set; then
4491 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4492 > else
4493 >  cat >conftest.$ac_ext <<_ACEOF
4494 >      subroutine foobar()
4495 >      return
4496 >      end
4497 >      subroutine foo_bar()
4498 >      return
4499 >      end
4500 > _ACEOF
4501 > rm -f conftest.$ac_objext
4502 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4503 >  (eval $ac_compile) 2>conftest.er1
4504 >  ac_status=$?
4505 >  grep -v '^ *+' conftest.er1 >conftest.err
4506 >  rm -f conftest.er1
4507 >  cat conftest.err >&5
4508 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4509 >  (exit $ac_status); } &&
4510 >         { ac_try='test -z "$ac_fc_werror_flag"
4511 >                         || test ! -s conftest.err'
4512 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4513 >  (eval $ac_try) 2>&5
4514 >  ac_status=$?
4515 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4516 >  (exit $ac_status); }; } &&
4517 >         { ac_try='test -s conftest.$ac_objext'
4518 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4519 >  (eval $ac_try) 2>&5
4520 >  ac_status=$?
4521 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4522 >  (exit $ac_status); }; }; then
4523 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4524 >
4525 >  ac_save_LIBS=$LIBS
4526 >  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4527 >
4528 >  ac_ext=c
4529 > ac_cpp='$CPP $CPPFLAGS'
4530 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4531 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4532 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4533 >  ac_success=no
4534 >  for ac_foobar in foobar FOOBAR; do
4535 >    for ac_underscore in "" "_"; do
4536 >      ac_func="$ac_foobar$ac_underscore"
4537 >      cat >conftest.$ac_ext <<_ACEOF
4538 > /* confdefs.h.  */
4539 > _ACEOF
4540 > cat confdefs.h >>conftest.$ac_ext
4541 > cat >>conftest.$ac_ext <<_ACEOF
4542 > /* end confdefs.h.  */
4543 >
4544 > /* Override any gcc2 internal prototype to avoid an error.  */
4545 > #ifdef __cplusplus
4546 > extern "C"
4547 > #endif
4548 > /* We use char because int might match the return type of a gcc2
4549 >   builtin and then its argument prototype would still apply.  */
4550 > char $ac_func ();
4551 > #ifdef FC_DUMMY_MAIN
4552 > #ifndef FC_DUMMY_MAIN_EQ_F77
4553 > #  ifdef __cplusplus
4554 >     extern "C"
4555 > #  endif
4556 >   int FC_DUMMY_MAIN() { return 1; }
4557 > #endif
4558 > #endif
4559 > int
4560 > main ()
4561 > {
4562 > $ac_func ();
4563 >  ;
4564 >  return 0;
4565 > }
4566 > _ACEOF
4567 > rm -f conftest.$ac_objext conftest$ac_exeext
4568 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4569 >  (eval $ac_link) 2>conftest.er1
4570 >  ac_status=$?
4571 >  grep -v '^ *+' conftest.er1 >conftest.err
4572 >  rm -f conftest.er1
4573 >  cat conftest.err >&5
4574 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4575 >  (exit $ac_status); } &&
4576 >         { ac_try='test -z "$ac_c_werror_flag"
4577 >                         || test ! -s conftest.err'
4578 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4579 >  (eval $ac_try) 2>&5
4580 >  ac_status=$?
4581 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4582 >  (exit $ac_status); }; } &&
4583 >         { ac_try='test -s conftest$ac_exeext'
4584 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4585 >  (eval $ac_try) 2>&5
4586 >  ac_status=$?
4587 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4588 >  (exit $ac_status); }; }; then
4589 >  ac_success=yes; break 2
4590 > else
4591 >  echo "$as_me: failed program was:" >&5
4592 > sed 's/^/| /' conftest.$ac_ext >&5
4593 >
4594 > fi
4595 > rm -f conftest.err conftest.$ac_objext \
4596 >      conftest$ac_exeext conftest.$ac_ext
4597 >    done
4598 >  done
4599 >  ac_ext=${FC_SRCEXT-f}
4600 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4601 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4602 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4603 >
4604 >  if test "$ac_success" = "yes"; then
4605 >     case $ac_foobar in
4606 >        foobar)
4607 >           ac_case=lower
4608 >           ac_foo_bar=foo_bar
4609 >           ;;
4610 >        FOOBAR)
4611 >           ac_case=upper
4612 >           ac_foo_bar=FOO_BAR
4613 >           ;;
4614 >     esac
4615 >
4616 >     ac_ext=c
4617 > ac_cpp='$CPP $CPPFLAGS'
4618 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4619 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4620 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4621 >     ac_success_extra=no
4622 >     for ac_extra in "" "_"; do
4623 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4624 >        cat >conftest.$ac_ext <<_ACEOF
4625 > /* confdefs.h.  */
4626 > _ACEOF
4627 > cat confdefs.h >>conftest.$ac_ext
4628 > cat >>conftest.$ac_ext <<_ACEOF
4629 > /* end confdefs.h.  */
4630 >
4631 > /* Override any gcc2 internal prototype to avoid an error.  */
4632 > #ifdef __cplusplus
4633 > extern "C"
4634 > #endif
4635 > /* We use char because int might match the return type of a gcc2
4636 >   builtin and then its argument prototype would still apply.  */
4637 > char $ac_func ();
4638 > #ifdef FC_DUMMY_MAIN
4639 > #ifndef FC_DUMMY_MAIN_EQ_F77
4640 > #  ifdef __cplusplus
4641 >     extern "C"
4642 > #  endif
4643 >   int FC_DUMMY_MAIN() { return 1; }
4644 > #endif
4645 > #endif
4646 > int
4647 > main ()
4648 > {
4649 > $ac_func ();
4650 >  ;
4651 >  return 0;
4652 > }
4653 > _ACEOF
4654 > rm -f conftest.$ac_objext conftest$ac_exeext
4655 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4656 >  (eval $ac_link) 2>conftest.er1
4657 >  ac_status=$?
4658 >  grep -v '^ *+' conftest.er1 >conftest.err
4659 >  rm -f conftest.er1
4660 >  cat conftest.err >&5
4661 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4662 >  (exit $ac_status); } &&
4663 >         { ac_try='test -z "$ac_c_werror_flag"
4664 >                         || test ! -s conftest.err'
4665 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4666 >  (eval $ac_try) 2>&5
4667 >  ac_status=$?
4668 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4669 >  (exit $ac_status); }; } &&
4670 >         { ac_try='test -s conftest$ac_exeext'
4671 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4672 >  (eval $ac_try) 2>&5
4673 >  ac_status=$?
4674 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4675 >  (exit $ac_status); }; }; then
4676 >  ac_success_extra=yes; break
4677 > else
4678 >  echo "$as_me: failed program was:" >&5
4679 > sed 's/^/| /' conftest.$ac_ext >&5
4680 >
4681 > fi
4682 > rm -f conftest.err conftest.$ac_objext \
4683 >      conftest$ac_exeext conftest.$ac_ext
4684 >     done
4685 >     ac_ext=${FC_SRCEXT-f}
4686 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4687 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4688 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4689 >
4690 >     if test "$ac_success_extra" = "yes"; then
4691 >        ac_cv_fc_mangling="$ac_case case"
4692 >        if test -z "$ac_underscore"; then
4693 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4694 >        else
4695 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4696 >        fi
4697 >        if test -z "$ac_extra"; then
4698 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4699 >        else
4700 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4701 >        fi
4702 >      else
4703 >        ac_cv_fc_mangling="unknown"
4704 >      fi
4705 >  else
4706 >     ac_cv_fc_mangling="unknown"
4707 >  fi
4708 >
4709 >  LIBS=$ac_save_LIBS
4710 >  rm -f cfortran_test* conftest*
4711 > else
4712 >  echo "$as_me: failed program was:" >&5
4713 > sed 's/^/| /' conftest.$ac_ext >&5
4714 >
4715 > { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4716 > See \`config.log' for more details." >&5
4717 > echo "$as_me: error: cannot compile a simple Fortran program
4718 > See \`config.log' for more details." >&2;}
4719 >   { (exit 1); exit 1; }; }
4720 > fi
4721 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4722 >
4723 > fi
4724 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4725 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4726 >
4727 > ac_ext=${FC_SRCEXT-f}
4728 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4729 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4730 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4731 >
4732 > ac_ext=${FC_SRCEXT-f}
4733 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4734 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4735 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4736 >
4737 >
4738 > case $ac_cv_fc_mangling in
4739 >  "lower case, no underscore, no extra underscore")
4740 >          cat >>confdefs.h <<\_ACEOF
4741 > #define FC_FUNC(name,NAME) name
4742 > _ACEOF
4743 >
4744 >          cat >>confdefs.h <<\_ACEOF
4745 > #define FC_FUNC_(name,NAME) name
4746 > _ACEOF
4747 > ;;
4748 >  "lower case, no underscore, extra underscore")
4749 >          cat >>confdefs.h <<\_ACEOF
4750 > #define FC_FUNC(name,NAME) name
4751 > _ACEOF
4752 >
4753 >          cat >>confdefs.h <<\_ACEOF
4754 > #define FC_FUNC_(name,NAME) name ## _
4755 > _ACEOF
4756 > ;;
4757 >  "lower case, underscore, no extra underscore")
4758 >          cat >>confdefs.h <<\_ACEOF
4759 > #define FC_FUNC(name,NAME) name ## _
4760 > _ACEOF
4761 >
4762 >          cat >>confdefs.h <<\_ACEOF
4763 > #define FC_FUNC_(name,NAME) name ## _
4764 > _ACEOF
4765 > ;;
4766 >  "lower case, underscore, extra underscore")
4767 >          cat >>confdefs.h <<\_ACEOF
4768 > #define FC_FUNC(name,NAME) name ## _
4769 > _ACEOF
4770 >
4771 >          cat >>confdefs.h <<\_ACEOF
4772 > #define FC_FUNC_(name,NAME) name ## __
4773 > _ACEOF
4774 > ;;
4775 >  "upper case, no underscore, no extra underscore")
4776 >          cat >>confdefs.h <<\_ACEOF
4777 > #define FC_FUNC(name,NAME) NAME
4778 > _ACEOF
4779 >
4780 >          cat >>confdefs.h <<\_ACEOF
4781 > #define FC_FUNC_(name,NAME) NAME
4782 > _ACEOF
4783 > ;;
4784 >  "upper case, no underscore, extra underscore")
4785 >          cat >>confdefs.h <<\_ACEOF
4786 > #define FC_FUNC(name,NAME) NAME
4787 > _ACEOF
4788 >
4789 >          cat >>confdefs.h <<\_ACEOF
4790 > #define FC_FUNC_(name,NAME) NAME ## _
4791 > _ACEOF
4792 > ;;
4793 >  "upper case, underscore, no extra underscore")
4794 >          cat >>confdefs.h <<\_ACEOF
4795 > #define FC_FUNC(name,NAME) NAME ## _
4796 > _ACEOF
4797 >
4798 >          cat >>confdefs.h <<\_ACEOF
4799 > #define FC_FUNC_(name,NAME) NAME ## _
4800 > _ACEOF
4801 > ;;
4802 >  "upper case, underscore, extra underscore")
4803 >          cat >>confdefs.h <<\_ACEOF
4804 > #define FC_FUNC(name,NAME) NAME ## _
4805 > _ACEOF
4806 >
4807 >          cat >>confdefs.h <<\_ACEOF
4808 > #define FC_FUNC_(name,NAME) NAME ## __
4809 > _ACEOF
4810 > ;;
4811 >  *)
4812 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4813 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4814 >          ;;
4815 > esac
4816 >
4817 > ac_ext=${FC_SRCEXT-f}
4818 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4819 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4820 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4821 >
4822 >
4823 >
4824 > ac_ext=${FC_SRCEXT-f}
4825 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4826 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4827 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4828 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4829 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4830 > if test "${ac_cv_prog_fc_v+set}" = set; then
4831 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4832 > else
4833 >  cat >conftest.$ac_ext <<_ACEOF
4834 >      program main
4835 >
4836 >      end
4837 > _ACEOF
4838 > rm -f conftest.$ac_objext
4839 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4840 >  (eval $ac_compile) 2>conftest.er1
4841 >  ac_status=$?
4842 >  grep -v '^ *+' conftest.er1 >conftest.err
4843 >  rm -f conftest.er1
4844 >  cat conftest.err >&5
4845 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4846 >  (exit $ac_status); } &&
4847 >         { ac_try='test -z "$ac_fc_werror_flag"
4848 >                         || test ! -s conftest.err'
4849 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4850 >  (eval $ac_try) 2>&5
4851 >  ac_status=$?
4852 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4853 >  (exit $ac_status); }; } &&
4854 >         { ac_try='test -s conftest.$ac_objext'
4855 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4856 >  (eval $ac_try) 2>&5
4857 >  ac_status=$?
4858 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4859 >  (exit $ac_status); }; }; then
4860 >  ac_cv_prog_fc_v=
4861 > # Try some options frequently used verbose output
4862 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4863 >  cat >conftest.$ac_ext <<_ACEOF
4864 >      program main
4865 >
4866 >      end
4867 > _ACEOF
4868 >
4869 > # Compile and link our simple test program by passing a flag (argument
4870 > # 1 to this macro) to the Fortran compiler in order to get
4871 > # "verbose" output that we can then parse for the Fortran linker
4872 > # flags.
4873 > ac_save_FFLAGS=$FCFLAGS
4874 > FCFLAGS="$FCFLAGS $ac_verb"
4875 > (eval echo $as_me:4875: \"$ac_link\") >&5
4876 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4877 > echo "$ac_fc_v_output" >&5
4878 > FCFLAGS=$ac_save_FFLAGS
4879 >
4880 > rm -f conftest*
4881 >
4882 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4883 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4884 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4885 > ac_fc_v_output="`echo $ac_fc_v_output |
4886 >        grep 'LPATH is:' |
4887 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4888 >
4889 > case $ac_fc_v_output in
4890 >  # If we are using xlf then replace all the commas with spaces.
4891 >  *xlfentry*)
4892 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4893 >
4894 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4895 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4896 >  *mGLOB_options_string*)
4897 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4898 >
4899 >  # If we are using Cray Fortran then delete quotes.
4900 >  # Use "\"" instead of '"' for font-lock-mode.
4901 >  # FIXME: a more general fix for quoted arguments with spaces?
4902 >  *cft90*)
4903 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4904 > esac
4905 >
4906 >
4907 >  # look for -l* and *.a constructs in the output
4908 >  for ac_arg in $ac_fc_v_output; do
4909 >     case $ac_arg in
4910 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4911 >          ac_cv_prog_fc_v=$ac_verb
4912 >          break 2 ;;
4913 >     esac
4914 >  done
4915 > done
4916 > if test -z "$ac_cv_prog_fc_v"; then
4917 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4918 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4919 > fi
4920 > else
4921 >  echo "$as_me: failed program was:" >&5
4922 > sed 's/^/| /' conftest.$ac_ext >&5
4923 >
4924 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4925 > echo "$as_me: WARNING: compilation failed" >&2;}
4926 > fi
4927 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4928 >
4929 > fi
4930 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4931 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4932 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4933 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4934 > if test "${ac_cv_fc_libs+set}" = set; then
4935 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4936 > else
4937 >  if test "x$FCLIBS" != "x"; then
4938 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4939 > else
4940 >
4941 > cat >conftest.$ac_ext <<_ACEOF
4942 >      program main
4943 >
4944 >      end
4945 > _ACEOF
4946 >
4947 > # Compile and link our simple test program by passing a flag (argument
4948 > # 1 to this macro) to the Fortran compiler in order to get
4949 > # "verbose" output that we can then parse for the Fortran linker
4950 > # flags.
4951 > ac_save_FFLAGS=$FCFLAGS
4952 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4953 > (eval echo $as_me:4953: \"$ac_link\") >&5
4954 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4955 > echo "$ac_fc_v_output" >&5
4956 > FCFLAGS=$ac_save_FFLAGS
4957 >
4958 > rm -f conftest*
4959 >
4960 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4961 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4962 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4963 > ac_fc_v_output="`echo $ac_fc_v_output |
4964 >        grep 'LPATH is:' |
4965 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4966 >
4967 > case $ac_fc_v_output in
4968 >  # If we are using xlf then replace all the commas with spaces.
4969 >  *xlfentry*)
4970 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4971 >
4972 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4973 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4974 >  *mGLOB_options_string*)
4975 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4976 >
4977 >  # If we are using Cray Fortran then delete quotes.
4978 >  # Use "\"" instead of '"' for font-lock-mode.
4979 >  # FIXME: a more general fix for quoted arguments with spaces?
4980 >  *cft90*)
4981 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4982 > esac
4983 >
4984 >
4985 >
4986 > ac_cv_fc_libs=
4987 >
4988 > # Save positional arguments (if any)
4989 > ac_save_positional="$@"
4990 >
4991 > set X $ac_fc_v_output
4992 > while test $# != 1; do
4993 >  shift
4994 >  ac_arg=$1
4995 >  case $ac_arg in
4996 >        [\\/]*.a | ?:[\\/]*.a)
4997 >            ac_exists=false
4998 >  for ac_i in $ac_cv_fc_libs; do
4999 >    if test x"$ac_arg" = x"$ac_i"; then
5000 >      ac_exists=true
5001 >      break
5002 >    fi
5003 >  done
5004 >
5005 >  if test x"$ac_exists" = xtrue; then
5006 >  :
5007 > else
5008 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5009 > fi
5010 >
5011 >          ;;
5012 >        -bI:*)
5013 >            ac_exists=false
5014 >  for ac_i in $ac_cv_fc_libs; do
5015 >    if test x"$ac_arg" = x"$ac_i"; then
5016 >      ac_exists=true
5017 >      break
5018 >    fi
5019 >  done
5020 >
5021 >  if test x"$ac_exists" = xtrue; then
5022 >  :
5023 > else
5024 >  if test "$ac_compiler_gnu" = yes; then
5025 >  for ac_link_opt in $ac_arg; do
5026 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5027 >  done
5028 > else
5029 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5030 > fi
5031 > fi
5032 >
5033 >          ;;
5034 >          # Ignore these flags.
5035 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5036 >          ;;
5037 >        -lkernel32)
5038 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5039 >          ;;
5040 >        -[LRuY])
5041 >          # These flags, when seen by themselves, take an argument.
5042 >          # We remove the space between option and argument and re-iterate
5043 >          # unless we find an empty arg or a new option (starting with -)
5044 >          case $2 in
5045 >             "" | -*);;
5046 >             *)
5047 >                ac_arg="$ac_arg$2"
5048 >                shift; shift
5049 >                set X $ac_arg "$@"
5050 >                ;;
5051 >          esac
5052 >          ;;
5053 >        -YP,*)
5054 >          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5055 >              ac_exists=false
5056 >  for ac_i in $ac_cv_fc_libs; do
5057 >    if test x"$ac_j" = x"$ac_i"; then
5058 >      ac_exists=true
5059 >      break
5060 >    fi
5061 >  done
5062 >
5063 >  if test x"$ac_exists" = xtrue; then
5064 >  :
5065 > else
5066 >  ac_arg="$ac_arg $ac_j"
5067 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5068 > fi
5069 >
5070 >          done
5071 >          ;;
5072 >        -[lLR]*)
5073 >            ac_exists=false
5074 >  for ac_i in $ac_cv_fc_libs; do
5075 >    if test x"$ac_arg" = x"$ac_i"; then
5076 >      ac_exists=true
5077 >      break
5078 >    fi
5079 >  done
5080 >
5081 >  if test x"$ac_exists" = xtrue; then
5082 >  :
5083 > else
5084 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5085 > fi
5086 >
5087 >          ;;
5088 >          # Ignore everything else.
5089 >  esac
5090 > done
5091 > # restore positional arguments
5092 > set X $ac_save_positional; shift
5093 >
5094 > # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5095 > # then we insist that the "run path" must be an absolute path (i.e. it
5096 > # must begin with a "/").
5097 > case `(uname -sr) 2>/dev/null` in
5098 >   "SunOS 5"*)
5099 >      ac_ld_run_path=`echo $ac_fc_v_output |
5100 >                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5101 >      test "x$ac_ld_run_path" != x &&
5102 >        if test "$ac_compiler_gnu" = yes; then
5103 >  for ac_link_opt in $ac_ld_run_path; do
5104 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5105 >  done
5106 > else
5107 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5108 > fi
5109 >      ;;
5110 > esac
5111 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5112 >
5113 > fi
5114 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5115 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
5116 > FCLIBS="$ac_cv_fc_libs"
5117 >
5118 >
5119 > ac_ext=${FC_SRCEXT-f}
5120 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5121 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5122 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5123 >
5124 >
5125 >
5126 > echo "$as_me:$LINENO: checking for module suffix" >&5
5127 > echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5128 > rm -f conftest*
5129 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5130 > rm -f work*
5131 > cat >conftest.$ac_ext <<EOF
5132 >        module conftest
5133 >        integer n
5134 >        parameter (n=1)
5135 >        end module conftest
5136 > EOF
5137 > # SGI and absoft compilers generates module name in upper case!
5138 > testname="conftest"
5139 > modcase="lower"
5140 > if (eval $ac_compile) 2>/dev/null ; then
5141 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5142 >    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5143 >    if test -z "$MOD" ; then
5144 >        MOD=`ls CONFTEST* 2>/dev/null \
5145 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5146 >        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5147 >        if test -n "$MOD" ; then
5148 >            testname="CONFTEST"
5149 >            modcase="upper"
5150 >        fi
5151 >    fi
5152 >    if test -z "$MOD" ; then
5153 >        echo "$as_me:$LINENO: result: unknown" >&5
5154 > echo "${ECHO_T}unknown" >&6
5155 >        # Use mod if we can't figure it out
5156 >        MOD="mod"
5157 >    else
5158 >        echo "$as_me:$LINENO: result: $MOD" >&5
5159 > echo "${ECHO_T}$MOD" >&6
5160 >    fi
5161 >    if test -s work.pcl ; then
5162 >        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
5163 > echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
5164 >    fi
5165 > else
5166 >    echo "$as_me:$LINENO: result: unknown" >&5
5167 > echo "${ECHO_T}unknown" >&6
5168 > fi
5169 >
5170 >
5171 >
5172 >
5173 >
5174 > # Check for module include path (some use -I, some (Solaris) use -M, some
5175 > # (absoft) use -p).
5176 > # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
5177 > # specified, work.pcl and work.pc are created.  However, if you specify
5178 > # a file, it must contain a the name of a file ending in .pc .  Ugh!
5179 > # Use the module made above
5180 > echo "$as_me:$LINENO: checking for module directory path flag" >&5
5181 > echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
5182 > rm -f conftest*
5183 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5184 > rm -f work*
5185 > cat >conftest.$ac_ext <<EOF
5186 >        module conftest
5187 >        integer n
5188 >        parameter (n=1)
5189 >        end module conftest
5190 > EOF
5191 > # SGI and absoft compilers generates module name in upper case!
5192 > testname="conftest"
5193 > if (eval $ac_compile) 2>/dev/null ; then
5194 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5195 >   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5196 >   if test -n "$mod" ; then
5197 >      testname="CONFTEST"
5198 >   fi
5199 >   madedir=0
5200 >   if test ! -d conf ; then mkdir conf ; madedir=1; fi
5201 >   cp $testname.$MOD conf
5202 >   rm -f conftest* CONFTEST*
5203 >   cat >conftest1.$ac_ext <<EOF
5204 >        program main
5205 >        use conftest
5206 >        print *, n
5207 >        end
5208 > EOF
5209 >   F90_WORK_FILES_ARG=""
5210 >   F90MODINCSPEC=""
5211 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5212 >       MODDIRFLAG="-I"
5213 >       F90MODINCSPEC="-I<dir>"
5214 >       echo "$as_me:$LINENO: result: -I" >&5
5215 > echo "${ECHO_T}-I" >&6
5216 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5217 >       MODDIRFLAG="-M"
5218 >       F90MODINCSPEC="-M<dir>"
5219 >       echo "$as_me:$LINENO: result: -M" >&5
5220 > echo "${ECHO_T}-M" >&6
5221 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5222 >       MODDIRFLAG="-p"
5223 >       F90MODINCSPEC="-p<dir>"
5224 >       echo "$as_me:$LINENO: result: -p" >&5
5225 > echo "${ECHO_T}-p" >&6
5226 >   elif test -s work.pc ; then
5227 >        cp work.pc conf/mpimod.pc
5228 >        echo "mpimod.pc" > conf/mpimod.pcl
5229 >        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5230 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5231 >            MODDIRFLAG='-cl,mpimod.pcl'
5232 >            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5233 > echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
5234 >            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
5235 >            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
5236 >
5237 >        else
5238 >            # The version of the Intel compiler that I have refuses to let
5239 >            # you put the "work catalog" list anywhere but the current
5240 >            # directory. For example, you cannot in
5241 >         :
5242 >        fi
5243 >   fi
5244 >   if test -z "MODDIRFLAG" ; then
5245 >       echo "$as_me:$LINENO: result: unknown" >&5
5246 > echo "${ECHO_T}unknown" >&6
5247 >   fi
5248 >
5249 >
5250 >   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
5251 >   if test $madedir = 1 ; then rmdir conf ; fi
5252 > fi
5253 >
5254 >
5255 > echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5256 > echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
5257 > if test "${ac_cv_f90_module_names+set}" = set; then
5258 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5259 > else
5260 >  ac_ext=${FC_SRCEXT-f}
5261 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5262 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5263 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5264 >
5265 > # carry out the test in a new directory, so that we don't miss anything
5266 > mkdir conftest
5267 > cd conftest
5268 > cat >conftest.$ac_ext <<_ACEOF
5269 > MODULE Bar
5270 > END MODULE Bar
5271 > _ACEOF
5272 > rm -f conftest.$ac_objext
5273 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5274 >  (eval $ac_compile) 2>conftest.er1
5275 >  ac_status=$?
5276 >  grep -v '^ *+' conftest.er1 >conftest.err
5277 >  rm -f conftest.er1
5278 >  cat conftest.err >&5
5279 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5280 >  (exit $ac_status); } &&
5281 >         { ac_try='test -z "$ac_fc_werror_flag"
5282 >                         || test ! -s conftest.err'
5283 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5284 >  (eval $ac_try) 2>&5
5285 >  ac_status=$?
5286 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5287 >  (exit $ac_status); }; } &&
5288 >         { ac_try='test -s conftest.$ac_objext'
5289 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5290 >  (eval $ac_try) 2>&5
5291 >  ac_status=$?
5292 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5293 >  (exit $ac_status); }; }; then
5294 >  ac_cv_f90_module_names=
5295 > ac_file_list=*
5296 > for ac_file in $ac_file_list; do
5297 >   case $ac_file in
5298 >      # don't care for original source and object files
5299 >      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
5300 >          :
5301 >          ;;
5302 >      # look for new files derived from the file name
5303 >      *conftest*)
5304 >          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
5305 >            ac_exists=false
5306 >  for ac_i in $ac_cv_f90_module_names; do
5307 >    if test x"$ac_pat" = x"$ac_i"; then
5308 >      ac_exists=true
5309 >      break
5310 >    fi
5311 >  done
5312 >
5313 >  if test x"$ac_exists" = xtrue; then
5314 >  :
5315 > else
5316 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5317 > fi
5318 >
5319 >          ;;
5320 >      # look for new files derived from the module name,
5321 >      # with different case translation schemes
5322 >      *Bar*)
5323 >          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
5324 >            ac_exists=false
5325 >  for ac_i in $ac_cv_f90_module_names; do
5326 >    if test x"$ac_pat" = x"$ac_i"; then
5327 >      ac_exists=true
5328 >      break
5329 >    fi
5330 >  done
5331 >
5332 >  if test x"$ac_exists" = xtrue; then
5333 >  :
5334 > else
5335 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5336 > fi
5337 >
5338 >          ;;
5339 >      *bar*)
5340 >          ac_pat=`echo $ac_file | sed s/bar/%module%/`
5341 >            ac_exists=false
5342 >  for ac_i in $ac_cv_f90_module_names; do
5343 >    if test x"$ac_pat" = x"$ac_i"; then
5344 >      ac_exists=true
5345 >      break
5346 >    fi
5347 >  done
5348 >
5349 >  if test x"$ac_exists" = xtrue; then
5350 >  :
5351 > else
5352 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5353 > fi
5354 >
5355 >          ;;
5356 >      *BAR*)
5357 >          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
5358 >            ac_exists=false
5359 >  for ac_i in $ac_cv_f90_module_names; do
5360 >    if test x"$ac_pat" = x"$ac_i"; then
5361 >      ac_exists=true
5362 >      break
5363 >    fi
5364 >  done
5365 >
5366 >  if test x"$ac_exists" = xtrue; then
5367 >  :
5368 > else
5369 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5370 > fi
5371 >
5372 >          ;;
5373 >       # Other files - we have no idea how they are generated
5374 >       *)
5375 >          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
5376 > echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
5377 >          ;;
5378 >   esac
5379 > done
5380 > if test "x$ac_cv_f90_module_names" = "x"; then
5381 >  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5382 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5383 > fi
5384 >
5385 > else
5386 >  echo "$as_me: failed program was:" >&5
5387 > sed 's/^/| /' conftest.$ac_ext >&5
5388 >
5389 > ac_cv_f90_module_names=
5390 > { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5391 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5392 > fi
5393 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5394 > cd ..
5395 > # cleanup
5396 > rm -rf conftest
5397 > ac_ext=${FC_SRCEXT-f}
5398 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5399 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5400 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5401 >
5402 > fi
5403 > echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
5404 > echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
5405 >
5406 > # We now generate a shell script that will help us to figure out the correct
5407 > # module file names, using the value of ac_cv_f90_module_names
5408 >
5409 > echo "Generating shell script modnam"
5410 >
5411 > cat > scripts/modnam << EOF
5412 > #! /bin/sh
5413 > # This script is auto-generated by configure
5414 > #
5415 > usage="\\
5416 > Usage: \$0 [FILES]
5417 >
5418 > [FILES] are Fortran 90 source files.
5419 > The output is a list of module file names that the Fortran 90 compiler
5420 > generates when compiling [FILES]."
5421 >
5422 > list=
5423 > empty=
5424 >
5425 > if test \$# -eq 0; then
5426 >   echo "\$usage"; exit 0
5427 > fi
5428 >
5429 > while test \$# != 0; do
5430 >
5431 >  file=\$1
5432 >  shift
5433 >
5434 > # strip suffix
5435 >  base=\`echo \$file | sed 's/[.][^.]*$//'\`
5436 >
5437 >  test ! -f \$file && continue
5438 >
5439 > # Look for module definitions and transform them to upper / lower case
5440 >  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/'\`
5441 >  upper=\`echo \$mods | tr a-z A-Z\`
5442 >  lower=\`echo \$mods | tr A-Z a-z\`
5443 >
5444 > # Here, the patterns for generating module file names were inserted by configure
5445 >  for trans in $ac_cv_f90_module_names; do
5446 >
5447 >    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
5448 >    var=empty
5449 >    case \$pat in
5450 >       %MODULE%)
5451 >          var=upper ;;
5452 >       %Module%)
5453 >          var=mods ;;
5454 >       %module%)
5455 >          var=lower ;;
5456 >       %FILE%)
5457 >          test -n "\$mods" && var=base ;;
5458 >    esac
5459 >    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
5460 >    list="\$list \$new"
5461 >  done
5462 > done
5463 >
5464 > echo \$list
5465 > # end of configure-generated script
5466 > EOF
5467 > chmod 755 scripts/modnam
5468 >
5469 > pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
5470 > F90_MODULE_NAMES=empty
5471 > case $pat in
5472 >       %MODULE%)
5473 >          F90_MODULE_NAMES=UPPER ;;
5474 >       %Module%)
5475 >          F90_MODULE_NAMES=Mixed ;;
5476 >       %module%)
5477 >          F90_MODULE_NAMES=lower ;;
5478 >       *)
5479 >          F90_MODULE_NAMES=unknown ;;
5480 > esac
5481 >
5482 > ac_ext=c
5483 > ac_cpp='$CPP $CPPFLAGS'
5484 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5485 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5486 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5487 >
5488 >
5489 > ac_ext=c
5490 > ac_cpp='$CPP $CPPFLAGS'
5491 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5492 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5493 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5494 >
5495 >
5496 >
5497 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5498 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5499 > if test "${ac_cv_lib_m_asin+set}" = set; then
5500 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5501 > else
5502 >  ac_check_lib_save_LIBS=$LIBS
5503 > LIBS="-lm  $LIBS"
5504 > cat >conftest.$ac_ext <<_ACEOF
5505 > /* confdefs.h.  */
5506 > _ACEOF
5507 > cat confdefs.h >>conftest.$ac_ext
5508 > cat >>conftest.$ac_ext <<_ACEOF
5509 > /* end confdefs.h.  */
5510 >
5511 > /* Override any gcc2 internal prototype to avoid an error.  */
5512 > #ifdef __cplusplus
5513 > extern "C"
5514 > #endif
5515 > /* We use char because int might match the return type of a gcc2
5516 >   builtin and then its argument prototype would still apply.  */
5517 > char asin ();
5518 > #ifdef FC_DUMMY_MAIN
5519 > #ifndef FC_DUMMY_MAIN_EQ_F77
5520 > #  ifdef __cplusplus
5521 >     extern "C"
5522 > #  endif
5523 >   int FC_DUMMY_MAIN() { return 1; }
5524 > #endif
5525 > #endif
5526 > int
5527 > main ()
5528 > {
5529 > asin ();
5530 >  ;
5531 >  return 0;
5532 > }
5533 > _ACEOF
5534 > rm -f conftest.$ac_objext conftest$ac_exeext
5535 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5536 >  (eval $ac_link) 2>conftest.er1
5537 >  ac_status=$?
5538 >  grep -v '^ *+' conftest.er1 >conftest.err
5539 >  rm -f conftest.er1
5540 >  cat conftest.err >&5
5541 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5542 >  (exit $ac_status); } &&
5543 >         { ac_try='test -z "$ac_c_werror_flag"
5544 >                         || test ! -s conftest.err'
5545 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5546 >  (eval $ac_try) 2>&5
5547 >  ac_status=$?
5548 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5549 >  (exit $ac_status); }; } &&
5550 >         { ac_try='test -s conftest$ac_exeext'
5551 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5552 >  (eval $ac_try) 2>&5
5553 >  ac_status=$?
5554 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5555 >  (exit $ac_status); }; }; then
5556 >  ac_cv_lib_m_asin=yes
5557 > else
5558 >  echo "$as_me: failed program was:" >&5
5559 > sed 's/^/| /' conftest.$ac_ext >&5
5560 >
5561 > ac_cv_lib_m_asin=no
5562 > fi
5563 > rm -f conftest.err conftest.$ac_objext \
5564 >      conftest$ac_exeext conftest.$ac_ext
5565 > LIBS=$ac_check_lib_save_LIBS
5566 > fi
5567 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5568 > echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5569 > if test $ac_cv_lib_m_asin = yes; then
5570 >  cat >>confdefs.h <<_ACEOF
5571 > #define HAVE_LIBM 1
5572 > _ACEOF
5573 >
5574 >  LIBS="-lm $LIBS"
5575 >
5576 > else
5577 >  exit
5578 > fi
5579 >
5580 >
5581 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5582 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5583 > if test "${ac_cv_header_stdc+set}" = set; then
5584 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5585 > else
5586 >  cat >conftest.$ac_ext <<_ACEOF
5587 > /* confdefs.h.  */
5588 > _ACEOF
5589 > cat confdefs.h >>conftest.$ac_ext
5590 > cat >>conftest.$ac_ext <<_ACEOF
5591 > /* end confdefs.h.  */
5592 > #include <stdlib.h>
5593 > #include <stdarg.h>
5594 > #include <string.h>
5595 > #include <float.h>
5596 >
5597 > #ifdef FC_DUMMY_MAIN
5598 > #ifndef FC_DUMMY_MAIN_EQ_F77
5599 > #  ifdef __cplusplus
5600 >     extern "C"
5601 > #  endif
5602 >   int FC_DUMMY_MAIN() { return 1; }
5603 > #endif
5604 > #endif
5605 > int
5606 > main ()
5607 > {
5608 >
5609 >  ;
5610 >  return 0;
5611 > }
5612 > _ACEOF
5613 > rm -f conftest.$ac_objext
5614 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5615 >  (eval $ac_compile) 2>conftest.er1
5616 >  ac_status=$?
5617 >  grep -v '^ *+' conftest.er1 >conftest.err
5618 >  rm -f conftest.er1
5619 >  cat conftest.err >&5
5620 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5621 >  (exit $ac_status); } &&
5622 >         { ac_try='test -z "$ac_c_werror_flag"
5623 >                         || test ! -s conftest.err'
5624 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5625 >  (eval $ac_try) 2>&5
5626 >  ac_status=$?
5627 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5628 >  (exit $ac_status); }; } &&
5629 >         { ac_try='test -s conftest.$ac_objext'
5630 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5631 >  (eval $ac_try) 2>&5
5632 >  ac_status=$?
5633 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5634 >  (exit $ac_status); }; }; then
5635 >  ac_cv_header_stdc=yes
5636 > else
5637 >  echo "$as_me: failed program was:" >&5
5638 > sed 's/^/| /' conftest.$ac_ext >&5
5639 >
5640 > ac_cv_header_stdc=no
5641 > fi
5642 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5643 >
5644 > if test $ac_cv_header_stdc = yes; then
5645 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5646 >  cat >conftest.$ac_ext <<_ACEOF
5647 > /* confdefs.h.  */
5648 > _ACEOF
5649 > cat confdefs.h >>conftest.$ac_ext
5650 > cat >>conftest.$ac_ext <<_ACEOF
5651 > /* end confdefs.h.  */
5652 > #include <string.h>
5653 >
5654 > _ACEOF
5655 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5656 >  $EGREP "memchr" >/dev/null 2>&1; then
5657 >  :
5658 > else
5659 >  ac_cv_header_stdc=no
5660 > fi
5661 > rm -f conftest*
5662 >
5663 > fi
5664 >
5665 > if test $ac_cv_header_stdc = yes; then
5666 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5667 >  cat >conftest.$ac_ext <<_ACEOF
5668 > /* confdefs.h.  */
5669 > _ACEOF
5670 > cat confdefs.h >>conftest.$ac_ext
5671 > cat >>conftest.$ac_ext <<_ACEOF
5672 > /* end confdefs.h.  */
5673 > #include <stdlib.h>
5674 >
5675 > _ACEOF
5676 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5677 >  $EGREP "free" >/dev/null 2>&1; then
5678 >  :
5679 > else
5680 >  ac_cv_header_stdc=no
5681 > fi
5682 > rm -f conftest*
5683 >
5684 > fi
5685 >
5686 > if test $ac_cv_header_stdc = yes; then
5687 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5688 >  if test "$cross_compiling" = yes; then
5689 >  :
5690 > else
5691 >  cat >conftest.$ac_ext <<_ACEOF
5692 > /* confdefs.h.  */
5693 > _ACEOF
5694 > cat confdefs.h >>conftest.$ac_ext
5695 > cat >>conftest.$ac_ext <<_ACEOF
5696 > /* end confdefs.h.  */
5697 > #include <ctype.h>
5698 > #if ((' ' & 0x0FF) == 0x020)
5699 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5700 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5701 > #else
5702 > # define ISLOWER(c) \
5703 >                   (('a' <= (c) && (c) <= 'i') \
5704 >                     || ('j' <= (c) && (c) <= 'r') \
5705 >                     || ('s' <= (c) && (c) <= 'z'))
5706 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5707 > #endif
5708 >
5709 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5710 > int
5711 > main ()
5712 > {
5713 >  int i;
5714 >  for (i = 0; i < 256; i++)
5715 >    if (XOR (islower (i), ISLOWER (i))
5716 >        || toupper (i) != TOUPPER (i))
5717 >      exit(2);
5718 >  exit (0);
5719 > }
5720 > _ACEOF
5721 > rm -f conftest$ac_exeext
5722 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5723 >  (eval $ac_link) 2>&5
5724 >  ac_status=$?
5725 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5726 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5727 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5728 >  (eval $ac_try) 2>&5
5729 >  ac_status=$?
5730 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5731 >  (exit $ac_status); }; }; then
5732 >  :
5733 > else
5734 >  echo "$as_me: program exited with status $ac_status" >&5
5735 > echo "$as_me: failed program was:" >&5
5736 > sed 's/^/| /' conftest.$ac_ext >&5
5737 >
5738 > ( exit $ac_status )
5739 > ac_cv_header_stdc=no
5740 > fi
5741 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5742 > fi
5743 > fi
5744 > fi
5745 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5746 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
5747 > if test $ac_cv_header_stdc = yes; then
5748 >
5749 > cat >>confdefs.h <<\_ACEOF
5750 > #define STDC_HEADERS 1
5751 > _ACEOF
5752 >
5753 > fi
5754 >
5755 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5756 >
5757 >
5758 >
5759 >
5760 >
5761 >
5762 >
5763 >
5764 >
5765 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5766 >                  inttypes.h stdint.h unistd.h
5767 > do
5768 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5769 > echo "$as_me:$LINENO: checking for $ac_header" >&5
5770 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5771 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
5772 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5773 > else
5774 >  cat >conftest.$ac_ext <<_ACEOF
5775 > /* confdefs.h.  */
5776 > _ACEOF
5777 > cat confdefs.h >>conftest.$ac_ext
5778 > cat >>conftest.$ac_ext <<_ACEOF
5779 > /* end confdefs.h.  */
5780 > $ac_includes_default
5781 >
5782 > #include <$ac_header>
5783 > _ACEOF
5784 > rm -f conftest.$ac_objext
5785 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5786 >  (eval $ac_compile) 2>conftest.er1
5787 >  ac_status=$?
5788 >  grep -v '^ *+' conftest.er1 >conftest.err
5789 >  rm -f conftest.er1
5790 >  cat conftest.err >&5
5791 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5792 >  (exit $ac_status); } &&
5793 >         { ac_try='test -z "$ac_c_werror_flag"
5794 >                         || test ! -s conftest.err'
5795 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5796 >  (eval $ac_try) 2>&5
5797 >  ac_status=$?
5798 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5799 >  (exit $ac_status); }; } &&
5800 >         { ac_try='test -s conftest.$ac_objext'
5801 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5802 >  (eval $ac_try) 2>&5
5803 >  ac_status=$?
5804 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5805 >  (exit $ac_status); }; }; then
5806 >  eval "$as_ac_Header=yes"
5807 > else
5808 >  echo "$as_me: failed program was:" >&5
5809 > sed 's/^/| /' conftest.$ac_ext >&5
5810 >
5811 > eval "$as_ac_Header=no"
5812 > fi
5813 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5814 > fi
5815 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5816 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5817 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
5818 >  cat >>confdefs.h <<_ACEOF
5819 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5820 > _ACEOF
5821 >
5822 > fi
5823 >
5824 > done
5825 >
5826 >
5827 > #
5828 > # Handle user hints
5829 > #
5830 >
5831 > # Check whether --with-zlib or --without-zlib was given.
5832 > if test "${with_zlib+set}" = set; then
5833 >  withval="$with_zlib"
5834 >  zlib_dir="$withval"
5835 > else
5836 >                zlib_dir="not_set"
5837 > fi;
5838 > if test "$zlib_dir" != "no"; then
5839 >
5840 > if test "$zlib_dir" != "not_set" ; then
5841 >  if test -d "$zlib_dir"
5842 >  then
5843 >    ZLIB_HOME="$zlib_dir"
5844 >  else
5845 >    { echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5846 > echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5847 >  fi
5848 > fi
5849 >
5850 > ZLIB_HOME=/usr/local
5851 > if test ! -f "${ZLIB_HOME}/include/zlib.h"
5852 > then
5853 >        ZLIB_HOME=/usr
5854 > fi
5855 >
5856 > #
5857 > # Locate zlib, if wanted
5858 > #
5859 > if test -n "${ZLIB_HOME}"
5860 > then
5861 >        ZLIB_OLD_LDFLAGS=$LDFLAGS
5862 >        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5863 >        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5864 >        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5865 >
5866 >
5867 >        ac_ext=c
5868 > ac_cpp='$CPP $CPPFLAGS'
5869 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5870 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5871 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5872 >
5873 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5874 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5875 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5876 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5877 > else
5878 >  ac_check_lib_save_LIBS=$LIBS
5879 > LIBS="-lz  $LIBS"
5880 > cat >conftest.$ac_ext <<_ACEOF
5881 > /* confdefs.h.  */
5882 > _ACEOF
5883 > cat confdefs.h >>conftest.$ac_ext
5884 > cat >>conftest.$ac_ext <<_ACEOF
5885 > /* end confdefs.h.  */
5886 >
5887 > /* Override any gcc2 internal prototype to avoid an error.  */
5888 > #ifdef __cplusplus
5889 > extern "C"
5890 > #endif
5891 > /* We use char because int might match the return type of a gcc2
5892 >   builtin and then its argument prototype would still apply.  */
5893 > char inflateEnd ();
5894 > #ifdef FC_DUMMY_MAIN
5895 > #ifndef FC_DUMMY_MAIN_EQ_F77
5896 > #  ifdef __cplusplus
5897 >     extern "C"
5898 > #  endif
5899 >   int FC_DUMMY_MAIN() { return 1; }
5900 > #endif
5901 > #endif
5902 > int
5903 > main ()
5904 > {
5905 > inflateEnd ();
5906 >  ;
5907 >  return 0;
5908 > }
5909 > _ACEOF
5910 > rm -f conftest.$ac_objext conftest$ac_exeext
5911 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5912 >  (eval $ac_link) 2>conftest.er1
5913 >  ac_status=$?
5914 >  grep -v '^ *+' conftest.er1 >conftest.err
5915 >  rm -f conftest.er1
5916 >  cat conftest.err >&5
5917 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5918 >  (exit $ac_status); } &&
5919 >         { ac_try='test -z "$ac_c_werror_flag"
5920 >                         || test ! -s conftest.err'
5921 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5922 >  (eval $ac_try) 2>&5
5923 >  ac_status=$?
5924 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5925 >  (exit $ac_status); }; } &&
5926 >         { ac_try='test -s conftest$ac_exeext'
5927 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5928 >  (eval $ac_try) 2>&5
5929 >  ac_status=$?
5930 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5931 >  (exit $ac_status); }; }; then
5932 >  ac_cv_lib_z_inflateEnd=yes
5933 > else
5934 >  echo "$as_me: failed program was:" >&5
5935 > sed 's/^/| /' conftest.$ac_ext >&5
5936 >
5937 > ac_cv_lib_z_inflateEnd=no
5938 > fi
5939 > rm -f conftest.err conftest.$ac_objext \
5940 >      conftest$ac_exeext conftest.$ac_ext
5941 > LIBS=$ac_check_lib_save_LIBS
5942 > fi
5943 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5944 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5945 > if test $ac_cv_lib_z_inflateEnd = yes; then
5946 >  zlib_cv_libz=yes
5947 > else
5948 >  zlib_cv_libz=no
5949 > fi
5950 >
5951 >        if test "${ac_cv_header_zlib_h+set}" = set; then
5952 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
5953 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5954 > if test "${ac_cv_header_zlib_h+set}" = set; then
5955 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5956 > fi
5957 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5958 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5959 > else
5960 >  # Is the header compilable?
5961 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
5962 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5963 > cat >conftest.$ac_ext <<_ACEOF
5964 > /* confdefs.h.  */
5965 > _ACEOF
5966 > cat confdefs.h >>conftest.$ac_ext
5967 > cat >>conftest.$ac_ext <<_ACEOF
5968 > /* end confdefs.h.  */
5969 > $ac_includes_default
5970 > #include <zlib.h>
5971 > _ACEOF
5972 > rm -f conftest.$ac_objext
5973 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5974 >  (eval $ac_compile) 2>conftest.er1
5975 >  ac_status=$?
5976 >  grep -v '^ *+' conftest.er1 >conftest.err
5977 >  rm -f conftest.er1
5978 >  cat conftest.err >&5
5979 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5980 >  (exit $ac_status); } &&
5981 >         { ac_try='test -z "$ac_c_werror_flag"
5982 >                         || test ! -s conftest.err'
5983 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5984 >  (eval $ac_try) 2>&5
5985 >  ac_status=$?
5986 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5987 >  (exit $ac_status); }; } &&
5988 >         { ac_try='test -s conftest.$ac_objext'
5989 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5990 >  (eval $ac_try) 2>&5
5991 >  ac_status=$?
5992 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5993 >  (exit $ac_status); }; }; then
5994 >  ac_header_compiler=yes
5995 > else
5996 >  echo "$as_me: failed program was:" >&5
5997 > sed 's/^/| /' conftest.$ac_ext >&5
5998 >
5999 > ac_header_compiler=no
6000 > fi
6001 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6002 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6003 > echo "${ECHO_T}$ac_header_compiler" >&6
6004 >
6005 > # Is the header present?
6006 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
6007 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
6008 > cat >conftest.$ac_ext <<_ACEOF
6009 > /* confdefs.h.  */
6010 > _ACEOF
6011 > cat confdefs.h >>conftest.$ac_ext
6012 > cat >>conftest.$ac_ext <<_ACEOF
6013 > /* end confdefs.h.  */
6014 > #include <zlib.h>
6015 > _ACEOF
6016 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6017 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6018 >  ac_status=$?
6019 >  grep -v '^ *+' conftest.er1 >conftest.err
6020 >  rm -f conftest.er1
6021 >  cat conftest.err >&5
6022 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6023 >  (exit $ac_status); } >/dev/null; then
6024 >  if test -s conftest.err; then
6025 >    ac_cpp_err=$ac_c_preproc_warn_flag
6026 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6027 >  else
6028 >    ac_cpp_err=
6029 >  fi
6030 > else
6031 >  ac_cpp_err=yes
6032 > fi
6033 > if test -z "$ac_cpp_err"; then
6034 >  ac_header_preproc=yes
6035 > else
6036 >  echo "$as_me: failed program was:" >&5
6037 > sed 's/^/| /' conftest.$ac_ext >&5
6038 >
6039 >  ac_header_preproc=no
6040 > fi
6041 > rm -f conftest.err conftest.$ac_ext
6042 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6043 > echo "${ECHO_T}$ac_header_preproc" >&6
6044 >
6045 > # So?  What about this header?
6046 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6047 >  yes:no: )
6048 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
6049 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6050 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
6051 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
6052 >    ac_header_preproc=yes
6053 >    ;;
6054 >  no:yes:* )
6055 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
6056 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
6057 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
6058 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
6059 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
6060 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
6061 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
6062 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6063 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
6064 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6065 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6066 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6067 >    (
6068 >      cat <<\_ASBOX
6069 > ## ------------------------------ ##
6070 > ## Report this to gezelter@nd.edu ##
6071 > ## ------------------------------ ##
6072 > _ASBOX
6073 >    ) |
6074 >      sed "s/^/$as_me: WARNING:     /" >&2
6075 >    ;;
6076 > esac
6077 > echo "$as_me:$LINENO: checking for zlib.h" >&5
6078 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6079 > if test "${ac_cv_header_zlib_h+set}" = set; then
6080 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6081 > else
6082 >  ac_cv_header_zlib_h=$ac_header_preproc
6083 > fi
6084 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6085 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6086 >
6087 > fi
6088 > if test $ac_cv_header_zlib_h = yes; then
6089 >  zlib_cv_zlib_h=yes
6090 > else
6091 >  zlib_cv_zlib_h=no
6092 > fi
6093 >
6094 >
6095 >        ac_ext=c
6096 > ac_cpp='$CPP $CPPFLAGS'
6097 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6098 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6099 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6100 >
6101 >
6102 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
6103 >
6104 > cat >>confdefs.h <<\_ACEOF
6105 > #define HAVE_ZLIB_H 1
6106 > _ACEOF
6107 >
6108 >
6109 > cat >>confdefs.h <<\_ACEOF
6110 > #define HAVE_LIBZ 1
6111 > _ACEOF
6112 >
6113 >                ZLIB_INC_DIR="${ZLIB_HOME}/include"
6114 >                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
6115 >                ZLIB="-lz"
6116 >        else
6117 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6118 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6119 >                ZLIB_INC_DIR=
6120 >                ZLIB_LIB_DIR=
6121 >                ZLIB=
6122 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6123 >                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6124 >                echo "$as_me:$LINENO: result: failed" >&5
6125 > echo "${ECHO_T}failed" >&6
6126 >                echo ""
6127 >                echo "*********************************************************"
6128 >                echo "* WARNING: Could not find a working zlib installation   *"
6129 >                echo "* If you need OOPSE to be able to deal with compressed  *"
6130 >                echo "* trajectory dump files be sure to specify a valid zlib *"
6131 >                echo "* installation with --with-zlib=DIR                     *"
6132 >                echo "*                                                       *"
6133 >                echo "* OOPSE will still work without zlib installed.         *"
6134 >                echo "*********************************************************"
6135 >                echo ""
6136 >        fi
6137 >
6138 >
6139 >
6140 > fi
6141 > fi
6142 >
6143 > #
6144 > # Handle user hints
6145 > #
6146 >
6147 > # Check whether --with-fftw or --without-fftw was given.
6148 > if test "${with_fftw+set}" = set; then
6149 >  withval="$with_fftw"
6150 >  fftw_dir="$withval"
6151 > else
6152 >                fftw_dir="not_set"
6153 > fi;
6154 > if test "$fftw_dir" != "no"; then
6155 >
6156 > if test "$fftw_dir" != "not_set" ; then
6157 >  if test -d "$fftw_dir"
6158 >  then
6159 >    FFTW_HOME="$fftw_dir"
6160 >  else
6161 >    { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6162 > echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6163 >  fi
6164 > fi
6165 >
6166 > FFTW_HOME=/usr/local
6167 > if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"
6168 > then
6169 >        FFTW_HOME=/usr
6170 > fi
6171 >
6172 > #
6173 > # Locate fftw, if wanted
6174 > #
6175 > if test -n "${FFTW_HOME}"
6176 > then
6177 >        FFTW_OLD_LDFLAGS=$LDFLAGS
6178 >        FFTW_OLD_CPPFLAGS=$LDFLAGS
6179 >        LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6180 >        CPPFLAGS="$CPPFLAGS -I${FFTW_HOME}/include"
6181 >
6182 >
6183 >        ac_ext=c
6184 > ac_cpp='$CPP $CPPFLAGS'
6185 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6186 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6187 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6188 >
6189 >        echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6190 > echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6191 > if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6192 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6193 > else
6194 >  ac_check_lib_save_LIBS=$LIBS
6195 > LIBS="-lfftw3  $LIBS"
6196 > cat >conftest.$ac_ext <<_ACEOF
6197 > /* confdefs.h.  */
6198 > _ACEOF
6199 > cat confdefs.h >>conftest.$ac_ext
6200 > cat >>conftest.$ac_ext <<_ACEOF
6201 > /* end confdefs.h.  */
6202 >
6203 > /* Override any gcc2 internal prototype to avoid an error.  */
6204 > #ifdef __cplusplus
6205 > extern "C"
6206 > #endif
6207 > /* We use char because int might match the return type of a gcc2
6208 >   builtin and then its argument prototype would still apply.  */
6209 > char fftw_execute ();
6210 > #ifdef FC_DUMMY_MAIN
6211 > #ifndef FC_DUMMY_MAIN_EQ_F77
6212 > #  ifdef __cplusplus
6213 >     extern "C"
6214 > #  endif
6215 >   int FC_DUMMY_MAIN() { return 1; }
6216 > #endif
6217 > #endif
6218 > int
6219 > main ()
6220 > {
6221 > fftw_execute ();
6222 >  ;
6223 >  return 0;
6224 > }
6225 > _ACEOF
6226 > rm -f conftest.$ac_objext conftest$ac_exeext
6227 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6228 >  (eval $ac_link) 2>conftest.er1
6229 >  ac_status=$?
6230 >  grep -v '^ *+' conftest.er1 >conftest.err
6231 >  rm -f conftest.er1
6232 >  cat conftest.err >&5
6233 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6234 >  (exit $ac_status); } &&
6235 >         { ac_try='test -z "$ac_c_werror_flag"
6236 >                         || test ! -s conftest.err'
6237 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6238 >  (eval $ac_try) 2>&5
6239 >  ac_status=$?
6240 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6241 >  (exit $ac_status); }; } &&
6242 >         { ac_try='test -s conftest$ac_exeext'
6243 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6244 >  (eval $ac_try) 2>&5
6245 >  ac_status=$?
6246 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6247 >  (exit $ac_status); }; }; then
6248 >  ac_cv_lib_fftw3_fftw_execute=yes
6249 > else
6250 >  echo "$as_me: failed program was:" >&5
6251 > sed 's/^/| /' conftest.$ac_ext >&5
6252 >
6253 > ac_cv_lib_fftw3_fftw_execute=no
6254 > fi
6255 > rm -f conftest.err conftest.$ac_objext \
6256 >      conftest$ac_exeext conftest.$ac_ext
6257 > LIBS=$ac_check_lib_save_LIBS
6258 > fi
6259 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6260 > echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6261 > if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6262 >  fftw_cv_libfftw3=yes
6263 > else
6264 >  fftw_cv_libfftw3=no
6265 > fi
6266 >
6267 >        if test "${ac_cv_header_fftw3_h+set}" = set; then
6268 >  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6269 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6270 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6271 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6272 > fi
6273 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6274 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6275 > else
6276 >  # Is the header compilable?
6277 > echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6278 > echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6279 > cat >conftest.$ac_ext <<_ACEOF
6280 > /* confdefs.h.  */
6281 > _ACEOF
6282 > cat confdefs.h >>conftest.$ac_ext
6283 > cat >>conftest.$ac_ext <<_ACEOF
6284 > /* end confdefs.h.  */
6285 > $ac_includes_default
6286 > #include <fftw3.h>
6287 > _ACEOF
6288 > rm -f conftest.$ac_objext
6289 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6290 >  (eval $ac_compile) 2>conftest.er1
6291 >  ac_status=$?
6292 >  grep -v '^ *+' conftest.er1 >conftest.err
6293 >  rm -f conftest.er1
6294 >  cat conftest.err >&5
6295 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6296 >  (exit $ac_status); } &&
6297 >         { ac_try='test -z "$ac_c_werror_flag"
6298 >                         || test ! -s conftest.err'
6299 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6300 >  (eval $ac_try) 2>&5
6301 >  ac_status=$?
6302 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6303 >  (exit $ac_status); }; } &&
6304 >         { ac_try='test -s conftest.$ac_objext'
6305 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6306 >  (eval $ac_try) 2>&5
6307 >  ac_status=$?
6308 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6309 >  (exit $ac_status); }; }; then
6310 >  ac_header_compiler=yes
6311 > else
6312 >  echo "$as_me: failed program was:" >&5
6313 > sed 's/^/| /' conftest.$ac_ext >&5
6314 >
6315 > ac_header_compiler=no
6316 > fi
6317 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6318 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6319 > echo "${ECHO_T}$ac_header_compiler" >&6
6320 >
6321 > # Is the header present?
6322 > echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6323 > echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6324 > cat >conftest.$ac_ext <<_ACEOF
6325 > /* confdefs.h.  */
6326 > _ACEOF
6327 > cat confdefs.h >>conftest.$ac_ext
6328 > cat >>conftest.$ac_ext <<_ACEOF
6329 > /* end confdefs.h.  */
6330 > #include <fftw3.h>
6331 > _ACEOF
6332 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6333 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6334 >  ac_status=$?
6335 >  grep -v '^ *+' conftest.er1 >conftest.err
6336 >  rm -f conftest.er1
6337 >  cat conftest.err >&5
6338 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6339 >  (exit $ac_status); } >/dev/null; then
6340 >  if test -s conftest.err; then
6341 >    ac_cpp_err=$ac_c_preproc_warn_flag
6342 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6343 >  else
6344 >    ac_cpp_err=
6345 >  fi
6346 > else
6347 >  ac_cpp_err=yes
6348 > fi
6349 > if test -z "$ac_cpp_err"; then
6350 >  ac_header_preproc=yes
6351 > else
6352 >  echo "$as_me: failed program was:" >&5
6353 > sed 's/^/| /' conftest.$ac_ext >&5
6354 >
6355 >  ac_header_preproc=no
6356 > fi
6357 > rm -f conftest.err conftest.$ac_ext
6358 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6359 > echo "${ECHO_T}$ac_header_preproc" >&6
6360 >
6361 > # So?  What about this header?
6362 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6363 >  yes:no: )
6364 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6365 > echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6366 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6367 > echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6368 >    ac_header_preproc=yes
6369 >    ;;
6370 >  no:yes:* )
6371 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6372 > echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6373 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6374 > echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6375 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6376 > echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6377 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6378 > echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6379 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6380 > echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6381 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6382 > echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6383 >    (
6384 >      cat <<\_ASBOX
6385 > ## ------------------------------ ##
6386 > ## Report this to gezelter@nd.edu ##
6387 > ## ------------------------------ ##
6388 > _ASBOX
6389 >    ) |
6390 >      sed "s/^/$as_me: WARNING:     /" >&2
6391 >    ;;
6392 > esac
6393 > echo "$as_me:$LINENO: checking for fftw3.h" >&5
6394 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6395 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6396 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6397 > else
6398 >  ac_cv_header_fftw3_h=$ac_header_preproc
6399 > fi
6400 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6401 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6402 >
6403 > fi
6404 > if test $ac_cv_header_fftw3_h = yes; then
6405 >  fftw_cv_fftw3_h=yes
6406 > else
6407 >  fftw_cv_fftw3_h=no
6408 > fi
6409 >
6410 >
6411 >        if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"
6412 >        then
6413 >                echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6414 > echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6415 > if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6416 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6417 > else
6418 >  ac_check_lib_save_LIBS=$LIBS
6419 > LIBS="-lfftw  $LIBS"
6420 > cat >conftest.$ac_ext <<_ACEOF
6421 > /* confdefs.h.  */
6422 > _ACEOF
6423 > cat confdefs.h >>conftest.$ac_ext
6424 > cat >>conftest.$ac_ext <<_ACEOF
6425 > /* end confdefs.h.  */
6426 >
6427 > /* Override any gcc2 internal prototype to avoid an error.  */
6428 > #ifdef __cplusplus
6429 > extern "C"
6430 > #endif
6431 > /* We use char because int might match the return type of a gcc2
6432 >   builtin and then its argument prototype would still apply.  */
6433 > char fftwnd_one ();
6434 > #ifdef FC_DUMMY_MAIN
6435 > #ifndef FC_DUMMY_MAIN_EQ_F77
6436 > #  ifdef __cplusplus
6437 >     extern "C"
6438 > #  endif
6439 >   int FC_DUMMY_MAIN() { return 1; }
6440 > #endif
6441 > #endif
6442 > int
6443 > main ()
6444 > {
6445 > fftwnd_one ();
6446 >  ;
6447 >  return 0;
6448 > }
6449 > _ACEOF
6450 > rm -f conftest.$ac_objext conftest$ac_exeext
6451 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6452 >  (eval $ac_link) 2>conftest.er1
6453 >  ac_status=$?
6454 >  grep -v '^ *+' conftest.er1 >conftest.err
6455 >  rm -f conftest.er1
6456 >  cat conftest.err >&5
6457 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6458 >  (exit $ac_status); } &&
6459 >         { ac_try='test -z "$ac_c_werror_flag"
6460 >                         || test ! -s conftest.err'
6461 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6462 >  (eval $ac_try) 2>&5
6463 >  ac_status=$?
6464 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6465 >  (exit $ac_status); }; } &&
6466 >         { ac_try='test -s conftest$ac_exeext'
6467 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6468 >  (eval $ac_try) 2>&5
6469 >  ac_status=$?
6470 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6471 >  (exit $ac_status); }; }; then
6472 >  ac_cv_lib_fftw_fftwnd_one=yes
6473 > else
6474 >  echo "$as_me: failed program was:" >&5
6475 > sed 's/^/| /' conftest.$ac_ext >&5
6476 >
6477 > ac_cv_lib_fftw_fftwnd_one=no
6478 > fi
6479 > rm -f conftest.err conftest.$ac_objext \
6480 >      conftest$ac_exeext conftest.$ac_ext
6481 > LIBS=$ac_check_lib_save_LIBS
6482 > fi
6483 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6484 > echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6485 > if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6486 >  fftw_cv_libfftw=yes
6487 > else
6488 >  fftw_cv_libfftw=no
6489 > fi
6490 >
6491 >                if test "${ac_cv_header_fftw_h+set}" = set; then
6492 >  echo "$as_me:$LINENO: checking for fftw.h" >&5
6493 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6494 > if test "${ac_cv_header_fftw_h+set}" = set; then
6495 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6496 > fi
6497 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6498 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6499 > else
6500 >  # Is the header compilable?
6501 > echo "$as_me:$LINENO: checking fftw.h usability" >&5
6502 > echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6503 > cat >conftest.$ac_ext <<_ACEOF
6504 > /* confdefs.h.  */
6505 > _ACEOF
6506 > cat confdefs.h >>conftest.$ac_ext
6507 > cat >>conftest.$ac_ext <<_ACEOF
6508 > /* end confdefs.h.  */
6509 > $ac_includes_default
6510 > #include <fftw.h>
6511 > _ACEOF
6512 > rm -f conftest.$ac_objext
6513 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6514 >  (eval $ac_compile) 2>conftest.er1
6515 >  ac_status=$?
6516 >  grep -v '^ *+' conftest.er1 >conftest.err
6517 >  rm -f conftest.er1
6518 >  cat conftest.err >&5
6519 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6520 >  (exit $ac_status); } &&
6521 >         { ac_try='test -z "$ac_c_werror_flag"
6522 >                         || test ! -s conftest.err'
6523 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6524 >  (eval $ac_try) 2>&5
6525 >  ac_status=$?
6526 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6527 >  (exit $ac_status); }; } &&
6528 >         { ac_try='test -s conftest.$ac_objext'
6529 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6530 >  (eval $ac_try) 2>&5
6531 >  ac_status=$?
6532 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6533 >  (exit $ac_status); }; }; then
6534 >  ac_header_compiler=yes
6535 > else
6536 >  echo "$as_me: failed program was:" >&5
6537 > sed 's/^/| /' conftest.$ac_ext >&5
6538 >
6539 > ac_header_compiler=no
6540 > fi
6541 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6542 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6543 > echo "${ECHO_T}$ac_header_compiler" >&6
6544 >
6545 > # Is the header present?
6546 > echo "$as_me:$LINENO: checking fftw.h presence" >&5
6547 > echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6548 > cat >conftest.$ac_ext <<_ACEOF
6549 > /* confdefs.h.  */
6550 > _ACEOF
6551 > cat confdefs.h >>conftest.$ac_ext
6552 > cat >>conftest.$ac_ext <<_ACEOF
6553 > /* end confdefs.h.  */
6554 > #include <fftw.h>
6555 > _ACEOF
6556 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6557 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6558 >  ac_status=$?
6559 >  grep -v '^ *+' conftest.er1 >conftest.err
6560 >  rm -f conftest.er1
6561 >  cat conftest.err >&5
6562 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6563 >  (exit $ac_status); } >/dev/null; then
6564 >  if test -s conftest.err; then
6565 >    ac_cpp_err=$ac_c_preproc_warn_flag
6566 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6567 >  else
6568 >    ac_cpp_err=
6569 >  fi
6570 > else
6571 >  ac_cpp_err=yes
6572 > fi
6573 > if test -z "$ac_cpp_err"; then
6574 >  ac_header_preproc=yes
6575 > else
6576 >  echo "$as_me: failed program was:" >&5
6577 > sed 's/^/| /' conftest.$ac_ext >&5
6578 >
6579 >  ac_header_preproc=no
6580 > fi
6581 > rm -f conftest.err conftest.$ac_ext
6582 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6583 > echo "${ECHO_T}$ac_header_preproc" >&6
6584 >
6585 > # So?  What about this header?
6586 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6587 >  yes:no: )
6588 >    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6589 > echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6590 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6591 > echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6592 >    ac_header_preproc=yes
6593 >    ;;
6594 >  no:yes:* )
6595 >    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6596 > echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6597 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6598 > echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6599 >    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6600 > echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6601 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6602 > echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6603 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6604 > echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6605 >    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6606 > echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6607 >    (
6608 >      cat <<\_ASBOX
6609 > ## ------------------------------ ##
6610 > ## Report this to gezelter@nd.edu ##
6611 > ## ------------------------------ ##
6612 > _ASBOX
6613 >    ) |
6614 >      sed "s/^/$as_me: WARNING:     /" >&2
6615 >    ;;
6616 > esac
6617 > echo "$as_me:$LINENO: checking for fftw.h" >&5
6618 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6619 > if test "${ac_cv_header_fftw_h+set}" = set; then
6620 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6621 > else
6622 >  ac_cv_header_fftw_h=$ac_header_preproc
6623 > fi
6624 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6625 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6626 >
6627 > fi
6628 > if test $ac_cv_header_fftw_h = yes; then
6629 >  fftw_cv_fftw_h=yes
6630 > else
6631 >  fftw_cv_fftw_h=no
6632 > fi
6633 >
6634 >
6635 >                if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"
6636 >                then
6637 >                        echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6638 > echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6639 > if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6640 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6641 > else
6642 >  ac_check_lib_save_LIBS=$LIBS
6643 > LIBS="-ldfftw  $LIBS"
6644 > cat >conftest.$ac_ext <<_ACEOF
6645 > /* confdefs.h.  */
6646 > _ACEOF
6647 > cat confdefs.h >>conftest.$ac_ext
6648 > cat >>conftest.$ac_ext <<_ACEOF
6649 > /* end confdefs.h.  */
6650 >
6651 > /* Override any gcc2 internal prototype to avoid an error.  */
6652 > #ifdef __cplusplus
6653 > extern "C"
6654 > #endif
6655 > /* We use char because int might match the return type of a gcc2
6656 >   builtin and then its argument prototype would still apply.  */
6657 > char fftwnd_one ();
6658 > #ifdef FC_DUMMY_MAIN
6659 > #ifndef FC_DUMMY_MAIN_EQ_F77
6660 > #  ifdef __cplusplus
6661 >     extern "C"
6662 > #  endif
6663 >   int FC_DUMMY_MAIN() { return 1; }
6664 > #endif
6665 > #endif
6666 > int
6667 > main ()
6668 > {
6669 > fftwnd_one ();
6670 >  ;
6671 >  return 0;
6672 > }
6673 > _ACEOF
6674 > rm -f conftest.$ac_objext conftest$ac_exeext
6675 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6676 >  (eval $ac_link) 2>conftest.er1
6677 >  ac_status=$?
6678 >  grep -v '^ *+' conftest.er1 >conftest.err
6679 >  rm -f conftest.er1
6680 >  cat conftest.err >&5
6681 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6682 >  (exit $ac_status); } &&
6683 >         { ac_try='test -z "$ac_c_werror_flag"
6684 >                         || test ! -s conftest.err'
6685 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6686 >  (eval $ac_try) 2>&5
6687 >  ac_status=$?
6688 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6689 >  (exit $ac_status); }; } &&
6690 >         { ac_try='test -s conftest$ac_exeext'
6691 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6692 >  (eval $ac_try) 2>&5
6693 >  ac_status=$?
6694 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6695 >  (exit $ac_status); }; }; then
6696 >  ac_cv_lib_dfftw_fftwnd_one=yes
6697 > else
6698 >  echo "$as_me: failed program was:" >&5
6699 > sed 's/^/| /' conftest.$ac_ext >&5
6700 >
6701 > ac_cv_lib_dfftw_fftwnd_one=no
6702 > fi
6703 > rm -f conftest.err conftest.$ac_objext \
6704 >      conftest$ac_exeext conftest.$ac_ext
6705 > LIBS=$ac_check_lib_save_LIBS
6706 > fi
6707 > echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6708 > echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6709 > if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6710 >  fftw_cv_libdfftw=yes
6711 > else
6712 >  fftw_cv_libdfftw=no
6713 > fi
6714 >
6715 >                        if test "${ac_cv_header_dfftw_h+set}" = set; then
6716 >  echo "$as_me:$LINENO: checking for dfftw.h" >&5
6717 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6718 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6719 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6720 > fi
6721 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6722 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6723 > else
6724 >  # Is the header compilable?
6725 > echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6726 > echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6727 > cat >conftest.$ac_ext <<_ACEOF
6728 > /* confdefs.h.  */
6729 > _ACEOF
6730 > cat confdefs.h >>conftest.$ac_ext
6731 > cat >>conftest.$ac_ext <<_ACEOF
6732 > /* end confdefs.h.  */
6733 > $ac_includes_default
6734 > #include <dfftw.h>
6735 > _ACEOF
6736 > rm -f conftest.$ac_objext
6737 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6738 >  (eval $ac_compile) 2>conftest.er1
6739 >  ac_status=$?
6740 >  grep -v '^ *+' conftest.er1 >conftest.err
6741 >  rm -f conftest.er1
6742 >  cat conftest.err >&5
6743 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6744 >  (exit $ac_status); } &&
6745 >         { ac_try='test -z "$ac_c_werror_flag"
6746 >                         || test ! -s conftest.err'
6747 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6748 >  (eval $ac_try) 2>&5
6749 >  ac_status=$?
6750 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6751 >  (exit $ac_status); }; } &&
6752 >         { ac_try='test -s conftest.$ac_objext'
6753 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6754 >  (eval $ac_try) 2>&5
6755 >  ac_status=$?
6756 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6757 >  (exit $ac_status); }; }; then
6758 >  ac_header_compiler=yes
6759 > else
6760 >  echo "$as_me: failed program was:" >&5
6761 > sed 's/^/| /' conftest.$ac_ext >&5
6762 >
6763 > ac_header_compiler=no
6764 > fi
6765 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6766 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6767 > echo "${ECHO_T}$ac_header_compiler" >&6
6768 >
6769 > # Is the header present?
6770 > echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6771 > echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6772 > cat >conftest.$ac_ext <<_ACEOF
6773 > /* confdefs.h.  */
6774 > _ACEOF
6775 > cat confdefs.h >>conftest.$ac_ext
6776 > cat >>conftest.$ac_ext <<_ACEOF
6777 > /* end confdefs.h.  */
6778 > #include <dfftw.h>
6779 > _ACEOF
6780 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6781 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6782 >  ac_status=$?
6783 >  grep -v '^ *+' conftest.er1 >conftest.err
6784 >  rm -f conftest.er1
6785 >  cat conftest.err >&5
6786 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6787 >  (exit $ac_status); } >/dev/null; then
6788 >  if test -s conftest.err; then
6789 >    ac_cpp_err=$ac_c_preproc_warn_flag
6790 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6791 >  else
6792 >    ac_cpp_err=
6793 >  fi
6794 > else
6795 >  ac_cpp_err=yes
6796 > fi
6797 > if test -z "$ac_cpp_err"; then
6798 >  ac_header_preproc=yes
6799 > else
6800 >  echo "$as_me: failed program was:" >&5
6801 > sed 's/^/| /' conftest.$ac_ext >&5
6802 >
6803 >  ac_header_preproc=no
6804 > fi
6805 > rm -f conftest.err conftest.$ac_ext
6806 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6807 > echo "${ECHO_T}$ac_header_preproc" >&6
6808 >
6809 > # So?  What about this header?
6810 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6811 >  yes:no: )
6812 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6813 > echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6814 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6815 > echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6816 >    ac_header_preproc=yes
6817 >    ;;
6818 >  no:yes:* )
6819 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6820 > echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6821 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6822 > echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6823 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6824 > echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6825 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6826 > echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6827 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6828 > echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6829 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6830 > echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6831 >    (
6832 >      cat <<\_ASBOX
6833 > ## ------------------------------ ##
6834 > ## Report this to gezelter@nd.edu ##
6835 > ## ------------------------------ ##
6836 > _ASBOX
6837 >    ) |
6838 >      sed "s/^/$as_me: WARNING:     /" >&2
6839 >    ;;
6840 > esac
6841 > echo "$as_me:$LINENO: checking for dfftw.h" >&5
6842 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6843 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6844 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6845 > else
6846 >  ac_cv_header_dfftw_h=$ac_header_preproc
6847 > fi
6848 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6849 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6850 >
6851 > fi
6852 > if test $ac_cv_header_dfftw_h = yes; then
6853 >  fftw_cv_dfftw_h=yes
6854 > else
6855 >  fftw_cv_dfftw_h=no
6856 > fi
6857 >
6858 >
6859 >                fi
6860 >        fi
6861 >        ac_ext=c
6862 > ac_cpp='$CPP $CPPFLAGS'
6863 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6864 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6865 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6866 >
6867 >
6868 >        if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"
6869 >        then
6870 >
6871 > cat >>confdefs.h <<\_ACEOF
6872 > #define HAVE_FFTW3_H 1
6873 > _ACEOF
6874 >
6875 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6876 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6877 >                FFTW_LIBS="-lfftw3"
6878 >        else
6879 >        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"
6880 >        then
6881 >
6882 > cat >>confdefs.h <<\_ACEOF
6883 > #define HAVE_FFTW_H 1
6884 > _ACEOF
6885 >
6886 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6887 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6888 >                FFTW_LIBS="-lfftw"
6889 >        else
6890 >        if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"
6891 >        then
6892 >
6893 > cat >>confdefs.h <<\_ACEOF
6894 > #define HAVE_DFFTW_H 1
6895 > _ACEOF
6896 >
6897 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6898 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6899 >                FFTW_LIBS="-ldfftw"
6900 >        else
6901 >                echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6902 > echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6903 >                FFTW_INC_DIR=
6904 >                FFTW_LIB_DIR=
6905 >                FFTW_LIBS=
6906 >                LDFLAGS="$FFTW_OLD_LDFLAGS"
6907 >                CPPFLAGS="$FFTW_OLD_CPPFLAGS"
6908 >                echo "$as_me:$LINENO: result: failed" >&5
6909 > echo "${ECHO_T}failed" >&6
6910 >        echo ""
6911 >        echo "*********************************************************"
6912 >        echo "* WARNING: Could not find a working FFTW installation   *"
6913 >        echo "* If you need the staticProps program to be able to     *"
6914 >        echo "* compute undulation spectra, be sure to specify a      *"
6915 >        echo "* valid fftw installation with --with-fftw=DIR          *"
6916 >        echo "*                                                       *"
6917 >        echo "* OOPSE will still work without fftw installed.         *"
6918 >        echo "*********************************************************"
6919 >        echo ""
6920 >        fi
6921 >        fi
6922 >        fi
6923 >
6924 >
6925 >
6926 > fi
6927 > fi
6928 >
6929 >
6930 >
6931 > # Checks for header files.
6932 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6933 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6934 > if test "${ac_cv_header_stdc+set}" = set; then
6935 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6936 > else
6937 >  cat >conftest.$ac_ext <<_ACEOF
6938 > /* confdefs.h.  */
6939 > _ACEOF
6940 > cat confdefs.h >>conftest.$ac_ext
6941 > cat >>conftest.$ac_ext <<_ACEOF
6942 > /* end confdefs.h.  */
6943 > #include <stdlib.h>
6944 > #include <stdarg.h>
6945 > #include <string.h>
6946 > #include <float.h>
6947 >
6948 > #ifdef FC_DUMMY_MAIN
6949 > #ifndef FC_DUMMY_MAIN_EQ_F77
6950 > #  ifdef __cplusplus
6951 >     extern "C"
6952 > #  endif
6953 >   int FC_DUMMY_MAIN() { return 1; }
6954 > #endif
6955 > #endif
6956 > int
6957 > main ()
6958 > {
6959 >
6960 >  ;
6961 >  return 0;
6962 > }
6963 > _ACEOF
6964 > rm -f conftest.$ac_objext
6965 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6966 >  (eval $ac_compile) 2>conftest.er1
6967 >  ac_status=$?
6968 >  grep -v '^ *+' conftest.er1 >conftest.err
6969 >  rm -f conftest.er1
6970 >  cat conftest.err >&5
6971 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6972 >  (exit $ac_status); } &&
6973 >         { ac_try='test -z "$ac_c_werror_flag"
6974 >                         || test ! -s conftest.err'
6975 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6976 >  (eval $ac_try) 2>&5
6977 >  ac_status=$?
6978 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6979 >  (exit $ac_status); }; } &&
6980 >         { ac_try='test -s conftest.$ac_objext'
6981 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6982 >  (eval $ac_try) 2>&5
6983 >  ac_status=$?
6984 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6985 >  (exit $ac_status); }; }; then
6986 >  ac_cv_header_stdc=yes
6987 > else
6988 >  echo "$as_me: failed program was:" >&5
6989 > sed 's/^/| /' conftest.$ac_ext >&5
6990 >
6991 > ac_cv_header_stdc=no
6992 > fi
6993 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6994 >
6995 > if test $ac_cv_header_stdc = yes; then
6996 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6997 >  cat >conftest.$ac_ext <<_ACEOF
6998 > /* confdefs.h.  */
6999 > _ACEOF
7000 > cat confdefs.h >>conftest.$ac_ext
7001 > cat >>conftest.$ac_ext <<_ACEOF
7002 > /* end confdefs.h.  */
7003 > #include <string.h>
7004 >
7005 > _ACEOF
7006 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7007 >  $EGREP "memchr" >/dev/null 2>&1; then
7008 >  :
7009 > else
7010 >  ac_cv_header_stdc=no
7011 > fi
7012 > rm -f conftest*
7013 >
7014 > fi
7015 >
7016 > if test $ac_cv_header_stdc = yes; then
7017 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7018 >  cat >conftest.$ac_ext <<_ACEOF
7019 > /* confdefs.h.  */
7020 > _ACEOF
7021 > cat confdefs.h >>conftest.$ac_ext
7022 > cat >>conftest.$ac_ext <<_ACEOF
7023 > /* end confdefs.h.  */
7024 > #include <stdlib.h>
7025 >
7026 > _ACEOF
7027 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7028 >  $EGREP "free" >/dev/null 2>&1; then
7029 >  :
7030 > else
7031 >  ac_cv_header_stdc=no
7032 > fi
7033 > rm -f conftest*
7034 >
7035 > fi
7036 >
7037 > if test $ac_cv_header_stdc = yes; then
7038 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7039 >  if test "$cross_compiling" = yes; then
7040 >  :
7041 > else
7042 >  cat >conftest.$ac_ext <<_ACEOF
7043 > /* confdefs.h.  */
7044 > _ACEOF
7045 > cat confdefs.h >>conftest.$ac_ext
7046 > cat >>conftest.$ac_ext <<_ACEOF
7047 > /* end confdefs.h.  */
7048 > #include <ctype.h>
7049 > #if ((' ' & 0x0FF) == 0x020)
7050 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7051 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7052 > #else
7053 > # define ISLOWER(c) \
7054 >                   (('a' <= (c) && (c) <= 'i') \
7055 >                     || ('j' <= (c) && (c) <= 'r') \
7056 >                     || ('s' <= (c) && (c) <= 'z'))
7057 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7058 > #endif
7059 >
7060 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7061 > int
7062 > main ()
7063 > {
7064 >  int i;
7065 >  for (i = 0; i < 256; i++)
7066 >    if (XOR (islower (i), ISLOWER (i))
7067 >        || toupper (i) != TOUPPER (i))
7068 >      exit(2);
7069 >  exit (0);
7070 > }
7071 > _ACEOF
7072 > rm -f conftest$ac_exeext
7073 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7074 >  (eval $ac_link) 2>&5
7075 >  ac_status=$?
7076 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7077 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7078 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7079 >  (eval $ac_try) 2>&5
7080 >  ac_status=$?
7081 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7082 >  (exit $ac_status); }; }; then
7083 >  :
7084 > else
7085 >  echo "$as_me: program exited with status $ac_status" >&5
7086 > echo "$as_me: failed program was:" >&5
7087 > sed 's/^/| /' conftest.$ac_ext >&5
7088 >
7089 > ( exit $ac_status )
7090 > ac_cv_header_stdc=no
7091 > fi
7092 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7093 > fi
7094 > fi
7095 > fi
7096 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7097 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7098 > if test $ac_cv_header_stdc = yes; then
7099 >
7100 > cat >>confdefs.h <<\_ACEOF
7101 > #define STDC_HEADERS 1
7102 > _ACEOF
7103 >
7104 > fi
7105 >
7106 >
7107 >
7108 >
7109 >
7110 >
7111 >
7112 >
7113 >
7114 >
7115 >
7116 >
7117 >
7118 >
7119 >
7120 >
7121 >
7122 >
7123 >
7124 >
7125 >
7126 >
7127 >
7128 >
7129 >
7130 >
7131 > 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
7132 > do
7133 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7134 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7135 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7136 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7137 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7138 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7139 > fi
7140 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7141 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7142 > else
7143 >  # Is the header compilable?
7144 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7145 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7146 > cat >conftest.$ac_ext <<_ACEOF
7147 > /* confdefs.h.  */
7148 > _ACEOF
7149 > cat confdefs.h >>conftest.$ac_ext
7150 > cat >>conftest.$ac_ext <<_ACEOF
7151 > /* end confdefs.h.  */
7152 > $ac_includes_default
7153 > #include <$ac_header>
7154 > _ACEOF
7155 > rm -f conftest.$ac_objext
7156 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7157 >  (eval $ac_compile) 2>conftest.er1
7158 >  ac_status=$?
7159 >  grep -v '^ *+' conftest.er1 >conftest.err
7160 >  rm -f conftest.er1
7161 >  cat conftest.err >&5
7162 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7163 >  (exit $ac_status); } &&
7164 >         { ac_try='test -z "$ac_c_werror_flag"
7165 >                         || test ! -s conftest.err'
7166 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7167 >  (eval $ac_try) 2>&5
7168 >  ac_status=$?
7169 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7170 >  (exit $ac_status); }; } &&
7171 >         { ac_try='test -s conftest.$ac_objext'
7172 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7173 >  (eval $ac_try) 2>&5
7174 >  ac_status=$?
7175 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7176 >  (exit $ac_status); }; }; then
7177 >  ac_header_compiler=yes
7178 > else
7179 >  echo "$as_me: failed program was:" >&5
7180 > sed 's/^/| /' conftest.$ac_ext >&5
7181 >
7182 > ac_header_compiler=no
7183 > fi
7184 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7185 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7186 > echo "${ECHO_T}$ac_header_compiler" >&6
7187 >
7188 > # Is the header present?
7189 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7190 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7191 > cat >conftest.$ac_ext <<_ACEOF
7192 > /* confdefs.h.  */
7193 > _ACEOF
7194 > cat confdefs.h >>conftest.$ac_ext
7195 > cat >>conftest.$ac_ext <<_ACEOF
7196 > /* end confdefs.h.  */
7197 > #include <$ac_header>
7198 > _ACEOF
7199 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7200 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7201 >  ac_status=$?
7202 >  grep -v '^ *+' conftest.er1 >conftest.err
7203 >  rm -f conftest.er1
7204 >  cat conftest.err >&5
7205 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7206 >  (exit $ac_status); } >/dev/null; then
7207 >  if test -s conftest.err; then
7208 >    ac_cpp_err=$ac_c_preproc_warn_flag
7209 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7210 >  else
7211 >    ac_cpp_err=
7212 >  fi
7213 > else
7214 >  ac_cpp_err=yes
7215 > fi
7216 > if test -z "$ac_cpp_err"; then
7217 >  ac_header_preproc=yes
7218 > else
7219 >  echo "$as_me: failed program was:" >&5
7220 > sed 's/^/| /' conftest.$ac_ext >&5
7221 >
7222 >  ac_header_preproc=no
7223 > fi
7224 > rm -f conftest.err conftest.$ac_ext
7225 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7226 > echo "${ECHO_T}$ac_header_preproc" >&6
7227 >
7228 > # So?  What about this header?
7229 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7230 >  yes:no: )
7231 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7232 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7233 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7234 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7235 >    ac_header_preproc=yes
7236 >    ;;
7237 >  no:yes:* )
7238 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7239 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7240 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7241 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7242 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7243 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7244 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7245 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7246 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7247 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7248 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7249 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7250 >    (
7251 >      cat <<\_ASBOX
7252 > ## ------------------------------ ##
7253 > ## Report this to gezelter@nd.edu ##
7254 > ## ------------------------------ ##
7255 > _ASBOX
7256 >    ) |
7257 >      sed "s/^/$as_me: WARNING:     /" >&2
7258 >    ;;
7259 > esac
7260 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7261 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7262 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7263 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7264 > else
7265 >  eval "$as_ac_Header=\$ac_header_preproc"
7266 > fi
7267 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7268 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7269 >
7270 > fi
7271 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7272 >  cat >>confdefs.h <<_ACEOF
7273 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7274 > _ACEOF
7275 >
7276 > fi
7277 >
7278 > done
7279 >
7280 >
7281 > # Checks for typedefs, structures, and compiler characteristics.
7282 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7283 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7284 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7285 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7286 > else
7287 >  cat >conftest.$ac_ext <<_ACEOF
7288 > /* confdefs.h.  */
7289 > _ACEOF
7290 > cat confdefs.h >>conftest.$ac_ext
7291 > cat >>conftest.$ac_ext <<_ACEOF
7292 > /* end confdefs.h.  */
7293 >
7294 > #include <stdbool.h>
7295 > #ifndef bool
7296 > # error bool is not defined
7297 > #endif
7298 > #ifndef false
7299 > # error false is not defined
7300 > #endif
7301 > #if false
7302 > # error false is not 0
7303 > #endif
7304 > #ifndef true
7305 > # error true is not defined
7306 > #endif
7307 > #if true != 1
7308 > # error true is not 1
7309 > #endif
7310 > #ifndef __bool_true_false_are_defined
7311 > # error __bool_true_false_are_defined is not defined
7312 > #endif
7313 >
7314 >        struct s { _Bool s: 1; _Bool t; } s;
7315 >
7316 >        char a[true == 1 ? 1 : -1];
7317 >        char b[false == 0 ? 1 : -1];
7318 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7319 >        char d[(bool) -0.5 == true ? 1 : -1];
7320 >        bool e = &s;
7321 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7322 >        char g[true];
7323 >        char h[sizeof (_Bool)];
7324 >        char i[sizeof s.t];
7325 >
7326 > #ifdef FC_DUMMY_MAIN
7327 > #ifndef FC_DUMMY_MAIN_EQ_F77
7328 > #  ifdef __cplusplus
7329 >     extern "C"
7330 > #  endif
7331 >   int FC_DUMMY_MAIN() { return 1; }
7332 > #endif
7333 > #endif
7334 > int
7335 > main ()
7336 > {
7337 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7338 >  ;
7339 >  return 0;
7340 > }
7341 > _ACEOF
7342 > rm -f conftest.$ac_objext
7343 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7344 >  (eval $ac_compile) 2>conftest.er1
7345 >  ac_status=$?
7346 >  grep -v '^ *+' conftest.er1 >conftest.err
7347 >  rm -f conftest.er1
7348 >  cat conftest.err >&5
7349 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7350 >  (exit $ac_status); } &&
7351 >         { ac_try='test -z "$ac_c_werror_flag"
7352 >                         || test ! -s conftest.err'
7353 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7354 >  (eval $ac_try) 2>&5
7355 >  ac_status=$?
7356 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7357 >  (exit $ac_status); }; } &&
7358 >         { ac_try='test -s conftest.$ac_objext'
7359 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7360 >  (eval $ac_try) 2>&5
7361 >  ac_status=$?
7362 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7363 >  (exit $ac_status); }; }; then
7364 >  ac_cv_header_stdbool_h=yes
7365 > else
7366 >  echo "$as_me: failed program was:" >&5
7367 > sed 's/^/| /' conftest.$ac_ext >&5
7368 >
7369 > ac_cv_header_stdbool_h=no
7370 > fi
7371 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7372 > fi
7373 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7374 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7375 > echo "$as_me:$LINENO: checking for _Bool" >&5
7376 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7377 > if test "${ac_cv_type__Bool+set}" = set; then
7378 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7379 > else
7380 >  cat >conftest.$ac_ext <<_ACEOF
7381 > /* confdefs.h.  */
7382 > _ACEOF
7383 > cat confdefs.h >>conftest.$ac_ext
7384 > cat >>conftest.$ac_ext <<_ACEOF
7385 > /* end confdefs.h.  */
7386 > $ac_includes_default
7387 > #ifdef FC_DUMMY_MAIN
7388 > #ifndef FC_DUMMY_MAIN_EQ_F77
7389 > #  ifdef __cplusplus
7390 >     extern "C"
7391 > #  endif
7392 >   int FC_DUMMY_MAIN() { return 1; }
7393 > #endif
7394 > #endif
7395 > int
7396 > main ()
7397 > {
7398 > if ((_Bool *) 0)
7399 >  return 0;
7400 > if (sizeof (_Bool))
7401 >  return 0;
7402 >  ;
7403 >  return 0;
7404 > }
7405 > _ACEOF
7406 > rm -f conftest.$ac_objext
7407 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7408 >  (eval $ac_compile) 2>conftest.er1
7409 >  ac_status=$?
7410 >  grep -v '^ *+' conftest.er1 >conftest.err
7411 >  rm -f conftest.er1
7412 >  cat conftest.err >&5
7413 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7414 >  (exit $ac_status); } &&
7415 >         { ac_try='test -z "$ac_c_werror_flag"
7416 >                         || test ! -s conftest.err'
7417 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7418 >  (eval $ac_try) 2>&5
7419 >  ac_status=$?
7420 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7421 >  (exit $ac_status); }; } &&
7422 >         { ac_try='test -s conftest.$ac_objext'
7423 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7424 >  (eval $ac_try) 2>&5
7425 >  ac_status=$?
7426 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7427 >  (exit $ac_status); }; }; then
7428 >  ac_cv_type__Bool=yes
7429 > else
7430 >  echo "$as_me: failed program was:" >&5
7431 > sed 's/^/| /' conftest.$ac_ext >&5
7432 >
7433 > ac_cv_type__Bool=no
7434 > fi
7435 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7436 > fi
7437 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7438 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7439 > if test $ac_cv_type__Bool = yes; then
7440 >
7441 > cat >>confdefs.h <<_ACEOF
7442 > #define HAVE__BOOL 1
7443 > _ACEOF
7444 >
7445 >
7446 > fi
7447 >
7448 > if test $ac_cv_header_stdbool_h = yes; then
7449 >
7450 > cat >>confdefs.h <<\_ACEOF
7451 > #define HAVE_STDBOOL_H 1
7452 > _ACEOF
7453 >
7454 > fi
7455 >
7456 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7457 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7458 > if test "${ac_cv_c_const+set}" = set; then
7459 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7460 > else
7461 >  cat >conftest.$ac_ext <<_ACEOF
7462 > /* confdefs.h.  */
7463 > _ACEOF
7464 > cat confdefs.h >>conftest.$ac_ext
7465 > cat >>conftest.$ac_ext <<_ACEOF
7466 > /* end confdefs.h.  */
7467 >
7468 > #ifdef FC_DUMMY_MAIN
7469 > #ifndef FC_DUMMY_MAIN_EQ_F77
7470 > #  ifdef __cplusplus
7471 >     extern "C"
7472 > #  endif
7473 >   int FC_DUMMY_MAIN() { return 1; }
7474 > #endif
7475 > #endif
7476 > int
7477 > main ()
7478 > {
7479 > /* FIXME: Include the comments suggested by Paul. */
7480 > #ifndef __cplusplus
7481 >  /* Ultrix mips cc rejects this.  */
7482 >  typedef int charset[2];
7483 >  const charset x;
7484 >  /* SunOS 4.1.1 cc rejects this.  */
7485 >  char const *const *ccp;
7486 >  char **p;
7487 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7488 >  struct point {int x, y;};
7489 >  static struct point const zero = {0,0};
7490 >  /* AIX XL C 1.02.0.0 rejects this.
7491 >     It does not let you subtract one const X* pointer from another in
7492 >     an arm of an if-expression whose if-part is not a constant
7493 >     expression */
7494 >  const char *g = "string";
7495 >  ccp = &g + (g ? g-g : 0);
7496 >  /* HPUX 7.0 cc rejects these. */
7497 >  ++ccp;
7498 >  p = (char**) ccp;
7499 >  ccp = (char const *const *) p;
7500 >  { /* SCO 3.2v4 cc rejects this.  */
7501 >    char *t;
7502 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7503 >
7504 >    *t++ = 0;
7505 >  }
7506 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7507 >    int x[] = {25, 17};
7508 >    const int *foo = &x[0];
7509 >    ++foo;
7510 >  }
7511 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7512 >    typedef const int *iptr;
7513 >    iptr p = 0;
7514 >    ++p;
7515 >  }
7516 >  { /* AIX XL C 1.02.0.0 rejects this saying
7517 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7518 >    struct s { int j; const int *ap[3]; };
7519 >    struct s *b; b->j = 5;
7520 >  }
7521 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7522 >    const int foo = 10;
7523 >  }
7524 > #endif
7525 >
7526 >  ;
7527 >  return 0;
7528 > }
7529 > _ACEOF
7530 > rm -f conftest.$ac_objext
7531 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7532 >  (eval $ac_compile) 2>conftest.er1
7533 >  ac_status=$?
7534 >  grep -v '^ *+' conftest.er1 >conftest.err
7535 >  rm -f conftest.er1
7536 >  cat conftest.err >&5
7537 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7538 >  (exit $ac_status); } &&
7539 >         { ac_try='test -z "$ac_c_werror_flag"
7540 >                         || test ! -s conftest.err'
7541 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7542 >  (eval $ac_try) 2>&5
7543 >  ac_status=$?
7544 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7545 >  (exit $ac_status); }; } &&
7546 >         { ac_try='test -s conftest.$ac_objext'
7547 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7548 >  (eval $ac_try) 2>&5
7549 >  ac_status=$?
7550 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7551 >  (exit $ac_status); }; }; then
7552 >  ac_cv_c_const=yes
7553 > else
7554 >  echo "$as_me: failed program was:" >&5
7555 > sed 's/^/| /' conftest.$ac_ext >&5
7556 >
7557 > ac_cv_c_const=no
7558 > fi
7559 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7560 > fi
7561 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7562 > echo "${ECHO_T}$ac_cv_c_const" >&6
7563 > if test $ac_cv_c_const = no; then
7564 >
7565 > cat >>confdefs.h <<\_ACEOF
7566 > #define const
7567 > _ACEOF
7568 >
7569 > fi
7570 >
7571 > echo "$as_me:$LINENO: checking for inline" >&5
7572 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7573 > if test "${ac_cv_c_inline+set}" = set; then
7574 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7575 > else
7576 >  ac_cv_c_inline=no
7577 > for ac_kw in inline __inline__ __inline; do
7578 >  cat >conftest.$ac_ext <<_ACEOF
7579 > /* confdefs.h.  */
7580 > _ACEOF
7581 > cat confdefs.h >>conftest.$ac_ext
7582 > cat >>conftest.$ac_ext <<_ACEOF
7583 > /* end confdefs.h.  */
7584 > #ifndef __cplusplus
7585 > typedef int foo_t;
7586 > static $ac_kw foo_t static_foo () {return 0; }
7587 > $ac_kw foo_t foo () {return 0; }
7588 > #endif
7589 >
7590 > _ACEOF
7591 > rm -f conftest.$ac_objext
7592 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7593 >  (eval $ac_compile) 2>conftest.er1
7594 >  ac_status=$?
7595 >  grep -v '^ *+' conftest.er1 >conftest.err
7596 >  rm -f conftest.er1
7597 >  cat conftest.err >&5
7598 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7599 >  (exit $ac_status); } &&
7600 >         { ac_try='test -z "$ac_c_werror_flag"
7601 >                         || test ! -s conftest.err'
7602 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7603 >  (eval $ac_try) 2>&5
7604 >  ac_status=$?
7605 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7606 >  (exit $ac_status); }; } &&
7607 >         { ac_try='test -s conftest.$ac_objext'
7608 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7609 >  (eval $ac_try) 2>&5
7610 >  ac_status=$?
7611 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7612 >  (exit $ac_status); }; }; then
7613 >  ac_cv_c_inline=$ac_kw; break
7614 > else
7615 >  echo "$as_me: failed program was:" >&5
7616 > sed 's/^/| /' conftest.$ac_ext >&5
7617 >
7618 > fi
7619 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7620 > done
7621 >
7622 > fi
7623 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7624 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7625 >
7626 >
7627 > case $ac_cv_c_inline in
7628 >  inline | yes) ;;
7629 >  *)
7630 >    case $ac_cv_c_inline in
7631 >      no) ac_val=;;
7632 >      *) ac_val=$ac_cv_c_inline;;
7633 >    esac
7634 >    cat >>confdefs.h <<_ACEOF
7635 > #ifndef __cplusplus
7636 > #define inline $ac_val
7637 > #endif
7638 > _ACEOF
7639 >    ;;
7640 > esac
7641 >
7642 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7643 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7644 > if test "${ac_cv_c_restrict+set}" = set; then
7645 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7646 > else
7647 >  ac_cv_c_restrict=no
7648 >   # Try the official restrict keyword, then gcc's __restrict, and
7649 >   # the less common variants.
7650 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
7651 >     cat >conftest.$ac_ext <<_ACEOF
7652 > /* confdefs.h.  */
7653 > _ACEOF
7654 > cat confdefs.h >>conftest.$ac_ext
7655 > cat >>conftest.$ac_ext <<_ACEOF
7656 > /* end confdefs.h.  */
7657 > float * $ac_kw x;
7658 > _ACEOF
7659 > rm -f conftest.$ac_objext
7660 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7661 >  (eval $ac_compile) 2>conftest.er1
7662 >  ac_status=$?
7663 >  grep -v '^ *+' conftest.er1 >conftest.err
7664 >  rm -f conftest.er1
7665 >  cat conftest.err >&5
7666 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7667 >  (exit $ac_status); } &&
7668 >         { ac_try='test -z "$ac_c_werror_flag"
7669 >                         || test ! -s conftest.err'
7670 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7671 >  (eval $ac_try) 2>&5
7672 >  ac_status=$?
7673 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7674 >  (exit $ac_status); }; } &&
7675 >         { ac_try='test -s conftest.$ac_objext'
7676 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7677 >  (eval $ac_try) 2>&5
7678 >  ac_status=$?
7679 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7680 >  (exit $ac_status); }; }; then
7681 >  ac_cv_c_restrict=$ac_kw; break
7682 > else
7683 >  echo "$as_me: failed program was:" >&5
7684 > sed 's/^/| /' conftest.$ac_ext >&5
7685 >
7686 > fi
7687 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7688 >   done
7689 >
7690 > fi
7691 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7692 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
7693 > case $ac_cv_c_restrict in
7694 >   restrict) ;;
7695 >   no)
7696 > cat >>confdefs.h <<\_ACEOF
7697 > #define restrict
7698 > _ACEOF
7699 > ;;
7700 >   *)  cat >>confdefs.h <<_ACEOF
7701 > #define restrict $ac_cv_c_restrict
7702 > _ACEOF
7703 > ;;
7704 > esac
7705 >
7706 > echo "$as_me:$LINENO: checking for size_t" >&5
7707 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
7708 > if test "${ac_cv_type_size_t+set}" = set; then
7709 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7710 > else
7711 >  cat >conftest.$ac_ext <<_ACEOF
7712 > /* confdefs.h.  */
7713 > _ACEOF
7714 > cat confdefs.h >>conftest.$ac_ext
7715 > cat >>conftest.$ac_ext <<_ACEOF
7716 > /* end confdefs.h.  */
7717 > $ac_includes_default
7718 > #ifdef FC_DUMMY_MAIN
7719 > #ifndef FC_DUMMY_MAIN_EQ_F77
7720 > #  ifdef __cplusplus
7721 >     extern "C"
7722 > #  endif
7723 >   int FC_DUMMY_MAIN() { return 1; }
7724 > #endif
7725 > #endif
7726 > int
7727 > main ()
7728 > {
7729 > if ((size_t *) 0)
7730 >  return 0;
7731 > if (sizeof (size_t))
7732 >  return 0;
7733 >  ;
7734 >  return 0;
7735 > }
7736 > _ACEOF
7737 > rm -f conftest.$ac_objext
7738 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7739 >  (eval $ac_compile) 2>conftest.er1
7740 >  ac_status=$?
7741 >  grep -v '^ *+' conftest.er1 >conftest.err
7742 >  rm -f conftest.er1
7743 >  cat conftest.err >&5
7744 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7745 >  (exit $ac_status); } &&
7746 >         { ac_try='test -z "$ac_c_werror_flag"
7747 >                         || test ! -s conftest.err'
7748 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7749 >  (eval $ac_try) 2>&5
7750 >  ac_status=$?
7751 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7752 >  (exit $ac_status); }; } &&
7753 >         { ac_try='test -s conftest.$ac_objext'
7754 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7755 >  (eval $ac_try) 2>&5
7756 >  ac_status=$?
7757 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7758 >  (exit $ac_status); }; }; then
7759 >  ac_cv_type_size_t=yes
7760 > else
7761 >  echo "$as_me: failed program was:" >&5
7762 > sed 's/^/| /' conftest.$ac_ext >&5
7763 >
7764 > ac_cv_type_size_t=no
7765 > fi
7766 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7767 > fi
7768 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
7769 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
7770 > if test $ac_cv_type_size_t = yes; then
7771 >  :
7772 > else
7773 >
7774 > cat >>confdefs.h <<_ACEOF
7775 > #define size_t unsigned
7776 > _ACEOF
7777 >
7778 > fi
7779 >
7780 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
7781 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
7782 > if test "${ac_cv_header_time+set}" = set; then
7783 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7784 > else
7785 >  cat >conftest.$ac_ext <<_ACEOF
7786 > /* confdefs.h.  */
7787 > _ACEOF
7788 > cat confdefs.h >>conftest.$ac_ext
7789 > cat >>conftest.$ac_ext <<_ACEOF
7790 > /* end confdefs.h.  */
7791 > #include <sys/types.h>
7792 > #include <sys/time.h>
7793 > #include <time.h>
7794 >
7795 > #ifdef FC_DUMMY_MAIN
7796 > #ifndef FC_DUMMY_MAIN_EQ_F77
7797 > #  ifdef __cplusplus
7798 >     extern "C"
7799 > #  endif
7800 >   int FC_DUMMY_MAIN() { return 1; }
7801 > #endif
7802 > #endif
7803 > int
7804 > main ()
7805 > {
7806 > if ((struct tm *) 0)
7807 > return 0;
7808 >  ;
7809 >  return 0;
7810 > }
7811 > _ACEOF
7812 > rm -f conftest.$ac_objext
7813 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7814 >  (eval $ac_compile) 2>conftest.er1
7815 >  ac_status=$?
7816 >  grep -v '^ *+' conftest.er1 >conftest.err
7817 >  rm -f conftest.er1
7818 >  cat conftest.err >&5
7819 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7820 >  (exit $ac_status); } &&
7821 >         { ac_try='test -z "$ac_c_werror_flag"
7822 >                         || test ! -s conftest.err'
7823 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7824 >  (eval $ac_try) 2>&5
7825 >  ac_status=$?
7826 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7827 >  (exit $ac_status); }; } &&
7828 >         { ac_try='test -s conftest.$ac_objext'
7829 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7830 >  (eval $ac_try) 2>&5
7831 >  ac_status=$?
7832 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7833 >  (exit $ac_status); }; }; then
7834 >  ac_cv_header_time=yes
7835 > else
7836 >  echo "$as_me: failed program was:" >&5
7837 > sed 's/^/| /' conftest.$ac_ext >&5
7838 >
7839 > ac_cv_header_time=no
7840 > fi
7841 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7842 > fi
7843 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7844 > echo "${ECHO_T}$ac_cv_header_time" >&6
7845 > if test $ac_cv_header_time = yes; then
7846 >
7847 > cat >>confdefs.h <<\_ACEOF
7848 > #define TIME_WITH_SYS_TIME 1
7849 > _ACEOF
7850 >
7851 > fi
7852 >
7853 > echo "$as_me:$LINENO: checking for clock_t" >&5
7854 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7855 > if test "${ac_cv_type_clock_t+set}" = set; then
7856 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7857 > else
7858 >  cat >conftest.$ac_ext <<_ACEOF
7859 > /* confdefs.h.  */
7860 > _ACEOF
7861 > cat confdefs.h >>conftest.$ac_ext
7862 > cat >>conftest.$ac_ext <<_ACEOF
7863 > /* end confdefs.h.  */
7864 > $ac_includes_default
7865 > #ifdef FC_DUMMY_MAIN
7866 > #ifndef FC_DUMMY_MAIN_EQ_F77
7867 > #  ifdef __cplusplus
7868 >     extern "C"
7869 > #  endif
7870 >   int FC_DUMMY_MAIN() { return 1; }
7871 > #endif
7872 > #endif
7873 > int
7874 > main ()
7875 > {
7876 > if ((clock_t *) 0)
7877 >  return 0;
7878 > if (sizeof (clock_t))
7879 >  return 0;
7880 >  ;
7881 >  return 0;
7882 > }
7883 > _ACEOF
7884 > rm -f conftest.$ac_objext
7885 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7886 >  (eval $ac_compile) 2>conftest.er1
7887 >  ac_status=$?
7888 >  grep -v '^ *+' conftest.er1 >conftest.err
7889 >  rm -f conftest.er1
7890 >  cat conftest.err >&5
7891 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7892 >  (exit $ac_status); } &&
7893 >         { ac_try='test -z "$ac_c_werror_flag"
7894 >                         || test ! -s conftest.err'
7895 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7896 >  (eval $ac_try) 2>&5
7897 >  ac_status=$?
7898 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7899 >  (exit $ac_status); }; } &&
7900 >         { ac_try='test -s conftest.$ac_objext'
7901 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7902 >  (eval $ac_try) 2>&5
7903 >  ac_status=$?
7904 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7905 >  (exit $ac_status); }; }; then
7906 >  ac_cv_type_clock_t=yes
7907 > else
7908 >  echo "$as_me: failed program was:" >&5
7909 > sed 's/^/| /' conftest.$ac_ext >&5
7910 >
7911 > ac_cv_type_clock_t=no
7912 > fi
7913 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7914 > fi
7915 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7916 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7917 > if test $ac_cv_type_clock_t = yes; then
7918 >
7919 > cat >>confdefs.h <<_ACEOF
7920 > #define HAVE_CLOCK_T 1
7921 > _ACEOF
7922 >
7923 >
7924 > fi
7925 >
7926 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7927 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7928 > if test "${ac_cv_c_const+set}" = set; then
7929 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7930 > else
7931 >  cat >conftest.$ac_ext <<_ACEOF
7932 > /* confdefs.h.  */
7933 > _ACEOF
7934 > cat confdefs.h >>conftest.$ac_ext
7935 > cat >>conftest.$ac_ext <<_ACEOF
7936 > /* end confdefs.h.  */
7937 >
7938 > #ifdef FC_DUMMY_MAIN
7939 > #ifndef FC_DUMMY_MAIN_EQ_F77
7940 > #  ifdef __cplusplus
7941 >     extern "C"
7942 > #  endif
7943 >   int FC_DUMMY_MAIN() { return 1; }
7944 > #endif
7945 > #endif
7946 > int
7947 > main ()
7948 > {
7949 > /* FIXME: Include the comments suggested by Paul. */
7950 > #ifndef __cplusplus
7951 >  /* Ultrix mips cc rejects this.  */
7952 >  typedef int charset[2];
7953 >  const charset x;
7954 >  /* SunOS 4.1.1 cc rejects this.  */
7955 >  char const *const *ccp;
7956 >  char **p;
7957 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7958 >  struct point {int x, y;};
7959 >  static struct point const zero = {0,0};
7960 >  /* AIX XL C 1.02.0.0 rejects this.
7961 >     It does not let you subtract one const X* pointer from another in
7962 >     an arm of an if-expression whose if-part is not a constant
7963 >     expression */
7964 >  const char *g = "string";
7965 >  ccp = &g + (g ? g-g : 0);
7966 >  /* HPUX 7.0 cc rejects these. */
7967 >  ++ccp;
7968 >  p = (char**) ccp;
7969 >  ccp = (char const *const *) p;
7970 >  { /* SCO 3.2v4 cc rejects this.  */
7971 >    char *t;
7972 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7973 >
7974 >    *t++ = 0;
7975 >  }
7976 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7977 >    int x[] = {25, 17};
7978 >    const int *foo = &x[0];
7979 >    ++foo;
7980 >  }
7981 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7982 >    typedef const int *iptr;
7983 >    iptr p = 0;
7984 >    ++p;
7985 >  }
7986 >  { /* AIX XL C 1.02.0.0 rejects this saying
7987 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7988 >    struct s { int j; const int *ap[3]; };
7989 >    struct s *b; b->j = 5;
7990 >  }
7991 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7992 >    const int foo = 10;
7993 >  }
7994 > #endif
7995 >
7996 >  ;
7997 >  return 0;
7998 > }
7999 > _ACEOF
8000 > rm -f conftest.$ac_objext
8001 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8002 >  (eval $ac_compile) 2>conftest.er1
8003 >  ac_status=$?
8004 >  grep -v '^ *+' conftest.er1 >conftest.err
8005 >  rm -f conftest.er1
8006 >  cat conftest.err >&5
8007 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8008 >  (exit $ac_status); } &&
8009 >         { ac_try='test -z "$ac_c_werror_flag"
8010 >                         || test ! -s conftest.err'
8011 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8012 >  (eval $ac_try) 2>&5
8013 >  ac_status=$?
8014 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8015 >  (exit $ac_status); }; } &&
8016 >         { ac_try='test -s conftest.$ac_objext'
8017 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8018 >  (eval $ac_try) 2>&5
8019 >  ac_status=$?
8020 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8021 >  (exit $ac_status); }; }; then
8022 >  ac_cv_c_const=yes
8023 > else
8024 >  echo "$as_me: failed program was:" >&5
8025 > sed 's/^/| /' conftest.$ac_ext >&5
8026 >
8027 > ac_cv_c_const=no
8028 > fi
8029 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8030 > fi
8031 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8032 > echo "${ECHO_T}$ac_cv_c_const" >&6
8033 > if test $ac_cv_c_const = no; then
8034 >
8035 > cat >>confdefs.h <<\_ACEOF
8036 > #define const
8037 > _ACEOF
8038 >
8039 > fi
8040 >
8041 > echo "$as_me:$LINENO: checking for inline" >&5
8042 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8043 > if test "${ac_cv_c_inline+set}" = set; then
8044 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8045 > else
8046 >  ac_cv_c_inline=no
8047 > for ac_kw in inline __inline__ __inline; do
8048 >  cat >conftest.$ac_ext <<_ACEOF
8049 > /* confdefs.h.  */
8050 > _ACEOF
8051 > cat confdefs.h >>conftest.$ac_ext
8052 > cat >>conftest.$ac_ext <<_ACEOF
8053 > /* end confdefs.h.  */
8054 > #ifndef __cplusplus
8055 > typedef int foo_t;
8056 > static $ac_kw foo_t static_foo () {return 0; }
8057 > $ac_kw foo_t foo () {return 0; }
8058 > #endif
8059 >
8060 > _ACEOF
8061 > rm -f conftest.$ac_objext
8062 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8063 >  (eval $ac_compile) 2>conftest.er1
8064 >  ac_status=$?
8065 >  grep -v '^ *+' conftest.er1 >conftest.err
8066 >  rm -f conftest.er1
8067 >  cat conftest.err >&5
8068 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8069 >  (exit $ac_status); } &&
8070 >         { ac_try='test -z "$ac_c_werror_flag"
8071 >                         || test ! -s conftest.err'
8072 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8073 >  (eval $ac_try) 2>&5
8074 >  ac_status=$?
8075 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8076 >  (exit $ac_status); }; } &&
8077 >         { ac_try='test -s conftest.$ac_objext'
8078 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8079 >  (eval $ac_try) 2>&5
8080 >  ac_status=$?
8081 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8082 >  (exit $ac_status); }; }; then
8083 >  ac_cv_c_inline=$ac_kw; break
8084 > else
8085 >  echo "$as_me: failed program was:" >&5
8086 > sed 's/^/| /' conftest.$ac_ext >&5
8087 >
8088 > fi
8089 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8090 > done
8091 >
8092 > fi
8093 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8094 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8095 >
8096 >
8097 > case $ac_cv_c_inline in
8098 >  inline | yes) ;;
8099 >  *)
8100 >    case $ac_cv_c_inline in
8101 >      no) ac_val=;;
8102 >      *) ac_val=$ac_cv_c_inline;;
8103 >    esac
8104 >    cat >>confdefs.h <<_ACEOF
8105 > #ifndef __cplusplus
8106 > #define inline $ac_val
8107 > #endif
8108 > _ACEOF
8109 >    ;;
8110 > esac
8111 >
8112 >
8113 > # Checks for library functions.
8114 >
8115 > for ac_header in stdlib.h
8116 > do
8117 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8118 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8119 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8120 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8121 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8122 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8123 > fi
8124 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8125 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8126 > else
8127 >  # Is the header compilable?
8128 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8129 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8130 > cat >conftest.$ac_ext <<_ACEOF
8131 > /* confdefs.h.  */
8132 > _ACEOF
8133 > cat confdefs.h >>conftest.$ac_ext
8134 > cat >>conftest.$ac_ext <<_ACEOF
8135 > /* end confdefs.h.  */
8136 > $ac_includes_default
8137 > #include <$ac_header>
8138 > _ACEOF
8139 > rm -f conftest.$ac_objext
8140 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8141 >  (eval $ac_compile) 2>conftest.er1
8142 >  ac_status=$?
8143 >  grep -v '^ *+' conftest.er1 >conftest.err
8144 >  rm -f conftest.er1
8145 >  cat conftest.err >&5
8146 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8147 >  (exit $ac_status); } &&
8148 >         { ac_try='test -z "$ac_c_werror_flag"
8149 >                         || test ! -s conftest.err'
8150 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8151 >  (eval $ac_try) 2>&5
8152 >  ac_status=$?
8153 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8154 >  (exit $ac_status); }; } &&
8155 >         { ac_try='test -s conftest.$ac_objext'
8156 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8157 >  (eval $ac_try) 2>&5
8158 >  ac_status=$?
8159 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8160 >  (exit $ac_status); }; }; then
8161 >  ac_header_compiler=yes
8162 > else
8163 >  echo "$as_me: failed program was:" >&5
8164 > sed 's/^/| /' conftest.$ac_ext >&5
8165 >
8166 > ac_header_compiler=no
8167 > fi
8168 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8169 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8170 > echo "${ECHO_T}$ac_header_compiler" >&6
8171 >
8172 > # Is the header present?
8173 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8174 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8175 > cat >conftest.$ac_ext <<_ACEOF
8176 > /* confdefs.h.  */
8177 > _ACEOF
8178 > cat confdefs.h >>conftest.$ac_ext
8179 > cat >>conftest.$ac_ext <<_ACEOF
8180 > /* end confdefs.h.  */
8181 > #include <$ac_header>
8182 > _ACEOF
8183 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8184 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8185 >  ac_status=$?
8186 >  grep -v '^ *+' conftest.er1 >conftest.err
8187 >  rm -f conftest.er1
8188 >  cat conftest.err >&5
8189 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8190 >  (exit $ac_status); } >/dev/null; then
8191 >  if test -s conftest.err; then
8192 >    ac_cpp_err=$ac_c_preproc_warn_flag
8193 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8194 >  else
8195 >    ac_cpp_err=
8196 >  fi
8197 > else
8198 >  ac_cpp_err=yes
8199 > fi
8200 > if test -z "$ac_cpp_err"; then
8201 >  ac_header_preproc=yes
8202 > else
8203 >  echo "$as_me: failed program was:" >&5
8204 > sed 's/^/| /' conftest.$ac_ext >&5
8205 >
8206 >  ac_header_preproc=no
8207 > fi
8208 > rm -f conftest.err conftest.$ac_ext
8209 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8210 > echo "${ECHO_T}$ac_header_preproc" >&6
8211 >
8212 > # So?  What about this header?
8213 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8214 >  yes:no: )
8215 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8216 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8217 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8218 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8219 >    ac_header_preproc=yes
8220 >    ;;
8221 >  no:yes:* )
8222 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8223 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8224 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8225 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8226 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8227 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8228 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8229 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8230 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8231 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8232 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8233 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8234 >    (
8235 >      cat <<\_ASBOX
8236 > ## ------------------------------ ##
8237 > ## Report this to gezelter@nd.edu ##
8238 > ## ------------------------------ ##
8239 > _ASBOX
8240 >    ) |
8241 >      sed "s/^/$as_me: WARNING:     /" >&2
8242 >    ;;
8243 > esac
8244 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8245 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8246 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8247 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8248 > else
8249 >  eval "$as_ac_Header=\$ac_header_preproc"
8250 > fi
8251 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8252 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8253 >
8254 > fi
8255 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8256 >  cat >>confdefs.h <<_ACEOF
8257 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8258 > _ACEOF
8259 >
8260 > fi
8261 >
8262 > done
8263 >
8264 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8265 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8266 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8267 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8268 > else
8269 >  if test "$cross_compiling" = yes; then
8270 >  ac_cv_func_malloc_0_nonnull=no
8271 > else
8272 >  cat >conftest.$ac_ext <<_ACEOF
8273 > /* confdefs.h.  */
8274 > _ACEOF
8275 > cat confdefs.h >>conftest.$ac_ext
8276 > cat >>conftest.$ac_ext <<_ACEOF
8277 > /* end confdefs.h.  */
8278 > #if STDC_HEADERS || HAVE_STDLIB_H
8279 > # include <stdlib.h>
8280 > #else
8281 > char *malloc ();
8282 > #endif
8283 >
8284 > #ifdef FC_DUMMY_MAIN
8285 > #ifndef FC_DUMMY_MAIN_EQ_F77
8286 > #  ifdef __cplusplus
8287 >     extern "C"
8288 > #  endif
8289 >   int FC_DUMMY_MAIN() { return 1; }
8290 > #endif
8291 > #endif
8292 > int
8293 > main ()
8294 > {
8295 > exit (malloc (0) ? 0 : 1);
8296 >  ;
8297 >  return 0;
8298 > }
8299 > _ACEOF
8300 > rm -f conftest$ac_exeext
8301 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8302 >  (eval $ac_link) 2>&5
8303 >  ac_status=$?
8304 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8305 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8306 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8307 >  (eval $ac_try) 2>&5
8308 >  ac_status=$?
8309 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8310 >  (exit $ac_status); }; }; then
8311 >  ac_cv_func_malloc_0_nonnull=yes
8312 > else
8313 >  echo "$as_me: program exited with status $ac_status" >&5
8314 > echo "$as_me: failed program was:" >&5
8315 > sed 's/^/| /' conftest.$ac_ext >&5
8316 >
8317 > ( exit $ac_status )
8318 > ac_cv_func_malloc_0_nonnull=no
8319 > fi
8320 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8321 > fi
8322 > fi
8323 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8324 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8325 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8326 >
8327 > cat >>confdefs.h <<\_ACEOF
8328 > #define HAVE_MALLOC 1
8329 > _ACEOF
8330 >
8331 > else
8332 >  cat >>confdefs.h <<\_ACEOF
8333 > #define HAVE_MALLOC 0
8334 > _ACEOF
8335 >
8336 >   case $LIBOBJS in
8337 >    "malloc.$ac_objext"   | \
8338 >  *" malloc.$ac_objext"   | \
8339 >    "malloc.$ac_objext "* | \
8340 >  *" malloc.$ac_objext "* ) ;;
8341 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8342 > esac
8343 >
8344 >
8345 > cat >>confdefs.h <<\_ACEOF
8346 > #define malloc rpl_malloc
8347 > _ACEOF
8348 >
8349 > fi
8350 >
8351 >
8352 >
8353 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8354 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8355 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8356 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8357 > else
8358 >  if test "$cross_compiling" = yes; then
8359 >  ac_cv_func_memcmp_working=no
8360 > else
8361 >  cat >conftest.$ac_ext <<_ACEOF
8362 > /* confdefs.h.  */
8363 > _ACEOF
8364 > cat confdefs.h >>conftest.$ac_ext
8365 > cat >>conftest.$ac_ext <<_ACEOF
8366 > /* end confdefs.h.  */
8367 > $ac_includes_default
8368 > #ifdef FC_DUMMY_MAIN
8369 > #ifndef FC_DUMMY_MAIN_EQ_F77
8370 > #  ifdef __cplusplus
8371 >     extern "C"
8372 > #  endif
8373 >   int FC_DUMMY_MAIN() { return 1; }
8374 > #endif
8375 > #endif
8376 > int
8377 > main ()
8378 > {
8379 >
8380 >  /* Some versions of memcmp are not 8-bit clean.  */
8381 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8382 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8383 >    exit (1);
8384 >
8385 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8386 >     or more and with at least one buffer not starting on a 4-byte boundary.
8387 >     William Lewis provided this test program.   */
8388 >  {
8389 >    char foo[21];
8390 >    char bar[21];
8391 >    int i;
8392 >    for (i = 0; i < 4; i++)
8393 >      {
8394 >        char *a = foo + i;
8395 >        char *b = bar + i;
8396 >        strcpy (a, "--------01111111");
8397 >        strcpy (b, "--------10000000");
8398 >        if (memcmp (a, b, 16) >= 0)
8399 >          exit (1);
8400 >      }
8401 >    exit (0);
8402 >  }
8403 >
8404 >  ;
8405 >  return 0;
8406 > }
8407 > _ACEOF
8408 > rm -f conftest$ac_exeext
8409 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8410 >  (eval $ac_link) 2>&5
8411 >  ac_status=$?
8412 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8413 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8414 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8415 >  (eval $ac_try) 2>&5
8416 >  ac_status=$?
8417 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8418 >  (exit $ac_status); }; }; then
8419 >  ac_cv_func_memcmp_working=yes
8420 > else
8421 >  echo "$as_me: program exited with status $ac_status" >&5
8422 > echo "$as_me: failed program was:" >&5
8423 > sed 's/^/| /' conftest.$ac_ext >&5
8424 >
8425 > ( exit $ac_status )
8426 > ac_cv_func_memcmp_working=no
8427 > fi
8428 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8429 > fi
8430 > fi
8431 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8432 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8433 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8434 >    "memcmp.$ac_objext"   | \
8435 >  *" memcmp.$ac_objext"   | \
8436 >    "memcmp.$ac_objext "* | \
8437 >  *" memcmp.$ac_objext "* ) ;;
8438 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8439 > esac
8440 >
8441 >
8442 >
8443 > for ac_header in stdlib.h
8444 > do
8445 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8446 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8447 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8448 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8449 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8450 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8451 > fi
8452 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8453 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8454 > else
8455 >  # Is the header compilable?
8456 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8457 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8458 > cat >conftest.$ac_ext <<_ACEOF
8459 > /* confdefs.h.  */
8460 > _ACEOF
8461 > cat confdefs.h >>conftest.$ac_ext
8462 > cat >>conftest.$ac_ext <<_ACEOF
8463 > /* end confdefs.h.  */
8464 > $ac_includes_default
8465 > #include <$ac_header>
8466 > _ACEOF
8467 > rm -f conftest.$ac_objext
8468 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8469 >  (eval $ac_compile) 2>conftest.er1
8470 >  ac_status=$?
8471 >  grep -v '^ *+' conftest.er1 >conftest.err
8472 >  rm -f conftest.er1
8473 >  cat conftest.err >&5
8474 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8475 >  (exit $ac_status); } &&
8476 >         { ac_try='test -z "$ac_c_werror_flag"
8477 >                         || test ! -s conftest.err'
8478 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8479 >  (eval $ac_try) 2>&5
8480 >  ac_status=$?
8481 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8482 >  (exit $ac_status); }; } &&
8483 >         { ac_try='test -s conftest.$ac_objext'
8484 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8485 >  (eval $ac_try) 2>&5
8486 >  ac_status=$?
8487 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8488 >  (exit $ac_status); }; }; then
8489 >  ac_header_compiler=yes
8490 > else
8491 >  echo "$as_me: failed program was:" >&5
8492 > sed 's/^/| /' conftest.$ac_ext >&5
8493 >
8494 > ac_header_compiler=no
8495 > fi
8496 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8497 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8498 > echo "${ECHO_T}$ac_header_compiler" >&6
8499 >
8500 > # Is the header present?
8501 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8502 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8503 > cat >conftest.$ac_ext <<_ACEOF
8504 > /* confdefs.h.  */
8505 > _ACEOF
8506 > cat confdefs.h >>conftest.$ac_ext
8507 > cat >>conftest.$ac_ext <<_ACEOF
8508 > /* end confdefs.h.  */
8509 > #include <$ac_header>
8510 > _ACEOF
8511 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8512 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8513 >  ac_status=$?
8514 >  grep -v '^ *+' conftest.er1 >conftest.err
8515 >  rm -f conftest.er1
8516 >  cat conftest.err >&5
8517 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8518 >  (exit $ac_status); } >/dev/null; then
8519 >  if test -s conftest.err; then
8520 >    ac_cpp_err=$ac_c_preproc_warn_flag
8521 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8522 >  else
8523 >    ac_cpp_err=
8524 >  fi
8525 > else
8526 >  ac_cpp_err=yes
8527 > fi
8528 > if test -z "$ac_cpp_err"; then
8529 >  ac_header_preproc=yes
8530 > else
8531 >  echo "$as_me: failed program was:" >&5
8532 > sed 's/^/| /' conftest.$ac_ext >&5
8533 >
8534 >  ac_header_preproc=no
8535 > fi
8536 > rm -f conftest.err conftest.$ac_ext
8537 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8538 > echo "${ECHO_T}$ac_header_preproc" >&6
8539 >
8540 > # So?  What about this header?
8541 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8542 >  yes:no: )
8543 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8544 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8545 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8546 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8547 >    ac_header_preproc=yes
8548 >    ;;
8549 >  no:yes:* )
8550 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8551 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8552 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8553 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8554 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8555 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8556 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8557 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8558 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8559 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8560 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8561 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8562 >    (
8563 >      cat <<\_ASBOX
8564 > ## ------------------------------ ##
8565 > ## Report this to gezelter@nd.edu ##
8566 > ## ------------------------------ ##
8567 > _ASBOX
8568 >    ) |
8569 >      sed "s/^/$as_me: WARNING:     /" >&2
8570 >    ;;
8571 > esac
8572 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8573 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8574 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8575 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8576 > else
8577 >  eval "$as_ac_Header=\$ac_header_preproc"
8578 > fi
8579 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8580 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8581 >
8582 > fi
8583 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8584 >  cat >>confdefs.h <<_ACEOF
8585 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8586 > _ACEOF
8587 >
8588 > fi
8589 >
8590 > done
8591 >
8592 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8593 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8594 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8595 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8596 > else
8597 >  if test "$cross_compiling" = yes; then
8598 >  ac_cv_func_realloc_0_nonnull=no
8599 > else
8600 >  cat >conftest.$ac_ext <<_ACEOF
8601 > /* confdefs.h.  */
8602 > _ACEOF
8603 > cat confdefs.h >>conftest.$ac_ext
8604 > cat >>conftest.$ac_ext <<_ACEOF
8605 > /* end confdefs.h.  */
8606 > #if STDC_HEADERS || HAVE_STDLIB_H
8607 > # include <stdlib.h>
8608 > #else
8609 > char *realloc ();
8610 > #endif
8611 >
8612 > #ifdef FC_DUMMY_MAIN
8613 > #ifndef FC_DUMMY_MAIN_EQ_F77
8614 > #  ifdef __cplusplus
8615 >     extern "C"
8616 > #  endif
8617 >   int FC_DUMMY_MAIN() { return 1; }
8618 > #endif
8619 > #endif
8620 > int
8621 > main ()
8622 > {
8623 > exit (realloc (0, 0) ? 0 : 1);
8624 >  ;
8625 >  return 0;
8626 > }
8627 > _ACEOF
8628 > rm -f conftest$ac_exeext
8629 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8630 >  (eval $ac_link) 2>&5
8631 >  ac_status=$?
8632 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8633 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8634 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8635 >  (eval $ac_try) 2>&5
8636 >  ac_status=$?
8637 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8638 >  (exit $ac_status); }; }; then
8639 >  ac_cv_func_realloc_0_nonnull=yes
8640 > else
8641 >  echo "$as_me: program exited with status $ac_status" >&5
8642 > echo "$as_me: failed program was:" >&5
8643 > sed 's/^/| /' conftest.$ac_ext >&5
8644 >
8645 > ( exit $ac_status )
8646 > ac_cv_func_realloc_0_nonnull=no
8647 > fi
8648 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8649 > fi
8650 > fi
8651 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8652 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8653 > if test $ac_cv_func_realloc_0_nonnull = yes; then
8654 >
8655 > cat >>confdefs.h <<\_ACEOF
8656 > #define HAVE_REALLOC 1
8657 > _ACEOF
8658 >
8659 > else
8660 >  cat >>confdefs.h <<\_ACEOF
8661 > #define HAVE_REALLOC 0
8662 > _ACEOF
8663 >
8664 >   case $LIBOBJS in
8665 >    "realloc.$ac_objext"   | \
8666 >  *" realloc.$ac_objext"   | \
8667 >    "realloc.$ac_objext "* | \
8668 >  *" realloc.$ac_objext "* ) ;;
8669 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8670 > esac
8671 >
8672 >
8673 > cat >>confdefs.h <<\_ACEOF
8674 > #define realloc rpl_realloc
8675 > _ACEOF
8676 >
8677 > fi
8678 >
8679 >
8680 >
8681 >
8682 >
8683 > for ac_header in sys/select.h sys/socket.h
8684 > do
8685 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8686 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8687 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8688 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8689 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8690 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8691 > fi
8692 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8693 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8694 > else
8695 >  # Is the header compilable?
8696 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8697 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8698 > cat >conftest.$ac_ext <<_ACEOF
8699 > /* confdefs.h.  */
8700 > _ACEOF
8701 > cat confdefs.h >>conftest.$ac_ext
8702 > cat >>conftest.$ac_ext <<_ACEOF
8703 > /* end confdefs.h.  */
8704 > $ac_includes_default
8705 > #include <$ac_header>
8706 > _ACEOF
8707 > rm -f conftest.$ac_objext
8708 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8709 >  (eval $ac_compile) 2>conftest.er1
8710 >  ac_status=$?
8711 >  grep -v '^ *+' conftest.er1 >conftest.err
8712 >  rm -f conftest.er1
8713 >  cat conftest.err >&5
8714 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8715 >  (exit $ac_status); } &&
8716 >         { ac_try='test -z "$ac_c_werror_flag"
8717 >                         || test ! -s conftest.err'
8718 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8719 >  (eval $ac_try) 2>&5
8720 >  ac_status=$?
8721 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8722 >  (exit $ac_status); }; } &&
8723 >         { ac_try='test -s conftest.$ac_objext'
8724 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8725 >  (eval $ac_try) 2>&5
8726 >  ac_status=$?
8727 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8728 >  (exit $ac_status); }; }; then
8729 >  ac_header_compiler=yes
8730 > else
8731 >  echo "$as_me: failed program was:" >&5
8732 > sed 's/^/| /' conftest.$ac_ext >&5
8733 >
8734 > ac_header_compiler=no
8735 > fi
8736 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8737 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8738 > echo "${ECHO_T}$ac_header_compiler" >&6
8739 >
8740 > # Is the header present?
8741 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8742 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8743 > cat >conftest.$ac_ext <<_ACEOF
8744 > /* confdefs.h.  */
8745 > _ACEOF
8746 > cat confdefs.h >>conftest.$ac_ext
8747 > cat >>conftest.$ac_ext <<_ACEOF
8748 > /* end confdefs.h.  */
8749 > #include <$ac_header>
8750 > _ACEOF
8751 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8752 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8753 >  ac_status=$?
8754 >  grep -v '^ *+' conftest.er1 >conftest.err
8755 >  rm -f conftest.er1
8756 >  cat conftest.err >&5
8757 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8758 >  (exit $ac_status); } >/dev/null; then
8759 >  if test -s conftest.err; then
8760 >    ac_cpp_err=$ac_c_preproc_warn_flag
8761 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8762 >  else
8763 >    ac_cpp_err=
8764 >  fi
8765 > else
8766 >  ac_cpp_err=yes
8767 > fi
8768 > if test -z "$ac_cpp_err"; then
8769 >  ac_header_preproc=yes
8770 > else
8771 >  echo "$as_me: failed program was:" >&5
8772 > sed 's/^/| /' conftest.$ac_ext >&5
8773 >
8774 >  ac_header_preproc=no
8775 > fi
8776 > rm -f conftest.err conftest.$ac_ext
8777 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8778 > echo "${ECHO_T}$ac_header_preproc" >&6
8779 >
8780 > # So?  What about this header?
8781 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8782 >  yes:no: )
8783 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8784 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8785 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8786 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8787 >    ac_header_preproc=yes
8788 >    ;;
8789 >  no:yes:* )
8790 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8791 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8792 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8793 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8794 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8795 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8796 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8797 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8798 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8799 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8800 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8801 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8802 >    (
8803 >      cat <<\_ASBOX
8804 > ## ------------------------------ ##
8805 > ## Report this to gezelter@nd.edu ##
8806 > ## ------------------------------ ##
8807 > _ASBOX
8808 >    ) |
8809 >      sed "s/^/$as_me: WARNING:     /" >&2
8810 >    ;;
8811 > esac
8812 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8813 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8814 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8815 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8816 > else
8817 >  eval "$as_ac_Header=\$ac_header_preproc"
8818 > fi
8819 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8820 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8821 >
8822 > fi
8823 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8824 >  cat >>confdefs.h <<_ACEOF
8825 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8826 > _ACEOF
8827 >
8828 > fi
8829 >
8830 > done
8831 >
8832 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
8833 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8834 > if test "${ac_cv_func_select_args+set}" = set; then
8835 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8836 > else
8837 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8838 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8839 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8840 >   cat >conftest.$ac_ext <<_ACEOF
8841 > /* confdefs.h.  */
8842 > _ACEOF
8843 > cat confdefs.h >>conftest.$ac_ext
8844 > cat >>conftest.$ac_ext <<_ACEOF
8845 > /* end confdefs.h.  */
8846 > $ac_includes_default
8847 > #if HAVE_SYS_SELECT_H
8848 > # include <sys/select.h>
8849 > #endif
8850 > #if HAVE_SYS_SOCKET_H
8851 > # include <sys/socket.h>
8852 > #endif
8853 >
8854 > #ifdef FC_DUMMY_MAIN
8855 > #ifndef FC_DUMMY_MAIN_EQ_F77
8856 > #  ifdef __cplusplus
8857 >     extern "C"
8858 > #  endif
8859 >   int FC_DUMMY_MAIN() { return 1; }
8860 > #endif
8861 > #endif
8862 > int
8863 > main ()
8864 > {
8865 > extern int select ($ac_arg1,
8866 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
8867 >                                            $ac_arg5);
8868 >  ;
8869 >  return 0;
8870 > }
8871 > _ACEOF
8872 > rm -f conftest.$ac_objext
8873 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8874 >  (eval $ac_compile) 2>conftest.er1
8875 >  ac_status=$?
8876 >  grep -v '^ *+' conftest.er1 >conftest.err
8877 >  rm -f conftest.er1
8878 >  cat conftest.err >&5
8879 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8880 >  (exit $ac_status); } &&
8881 >         { ac_try='test -z "$ac_c_werror_flag"
8882 >                         || test ! -s conftest.err'
8883 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8884 >  (eval $ac_try) 2>&5
8885 >  ac_status=$?
8886 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8887 >  (exit $ac_status); }; } &&
8888 >         { ac_try='test -s conftest.$ac_objext'
8889 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8890 >  (eval $ac_try) 2>&5
8891 >  ac_status=$?
8892 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8893 >  (exit $ac_status); }; }; then
8894 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8895 > else
8896 >  echo "$as_me: failed program was:" >&5
8897 > sed 's/^/| /' conftest.$ac_ext >&5
8898 >
8899 > fi
8900 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8901 >  done
8902 > done
8903 > done
8904 > # Provide a safe default value.
8905 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
8906 >
8907 > fi
8908 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8909 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
8910 > ac_save_IFS=$IFS; IFS=','
8911 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8912 > IFS=$ac_save_IFS
8913 > shift
8914 >
8915 > cat >>confdefs.h <<_ACEOF
8916 > #define SELECT_TYPE_ARG1 $1
8917 > _ACEOF
8918 >
8919 >
8920 > cat >>confdefs.h <<_ACEOF
8921 > #define SELECT_TYPE_ARG234 ($2)
8922 > _ACEOF
8923 >
8924 >
8925 > cat >>confdefs.h <<_ACEOF
8926 > #define SELECT_TYPE_ARG5 ($3)
8927 > _ACEOF
8928 >
8929 > rm -f conftest*
8930 >
8931 >
8932 > for ac_func in strftime
8933 > do
8934 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8935 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8936 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8937 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8938 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8939 > else
8940 >  cat >conftest.$ac_ext <<_ACEOF
8941 > /* confdefs.h.  */
8942 > _ACEOF
8943 > cat confdefs.h >>conftest.$ac_ext
8944 > cat >>conftest.$ac_ext <<_ACEOF
8945 > /* end confdefs.h.  */
8946 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8947 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8948 > #define $ac_func innocuous_$ac_func
8949 >
8950 > /* System header to define __stub macros and hopefully few prototypes,
8951 >    which can conflict with char $ac_func (); below.
8952 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8953 >    <limits.h> exists even on freestanding compilers.  */
8954 >
8955 > #ifdef __STDC__
8956 > # include <limits.h>
8957 > #else
8958 > # include <assert.h>
8959 > #endif
8960 >
8961 > #undef $ac_func
8962 >
8963 > /* Override any gcc2 internal prototype to avoid an error.  */
8964 > #ifdef __cplusplus
8965 > extern "C"
8966 > {
8967 > #endif
8968 > /* We use char because int might match the return type of a gcc2
8969 >   builtin and then its argument prototype would still apply.  */
8970 > char $ac_func ();
8971 > /* The GNU C library defines this for functions which it implements
8972 >    to always fail with ENOSYS.  Some functions are actually named
8973 >    something starting with __ and the normal name is an alias.  */
8974 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8975 > choke me
8976 > #else
8977 > char (*f) () = $ac_func;
8978 > #endif
8979 > #ifdef __cplusplus
8980 > }
8981 > #endif
8982 >
8983 > #ifdef FC_DUMMY_MAIN
8984 > #ifndef FC_DUMMY_MAIN_EQ_F77
8985 > #  ifdef __cplusplus
8986 >     extern "C"
8987 > #  endif
8988 >   int FC_DUMMY_MAIN() { return 1; }
8989 > #endif
8990 > #endif
8991 > int
8992 > main ()
8993 > {
8994 > return f != $ac_func;
8995 >  ;
8996 >  return 0;
8997 > }
8998 > _ACEOF
8999 > rm -f conftest.$ac_objext conftest$ac_exeext
9000 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9001 >  (eval $ac_link) 2>conftest.er1
9002 >  ac_status=$?
9003 >  grep -v '^ *+' conftest.er1 >conftest.err
9004 >  rm -f conftest.er1
9005 >  cat conftest.err >&5
9006 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9007 >  (exit $ac_status); } &&
9008 >         { ac_try='test -z "$ac_c_werror_flag"
9009 >                         || test ! -s conftest.err'
9010 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9011 >  (eval $ac_try) 2>&5
9012 >  ac_status=$?
9013 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9014 >  (exit $ac_status); }; } &&
9015 >         { ac_try='test -s conftest$ac_exeext'
9016 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9017 >  (eval $ac_try) 2>&5
9018 >  ac_status=$?
9019 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9020 >  (exit $ac_status); }; }; then
9021 >  eval "$as_ac_var=yes"
9022 > else
9023 >  echo "$as_me: failed program was:" >&5
9024 > sed 's/^/| /' conftest.$ac_ext >&5
9025 >
9026 > eval "$as_ac_var=no"
9027 > fi
9028 > rm -f conftest.err conftest.$ac_objext \
9029 >      conftest$ac_exeext conftest.$ac_ext
9030 > fi
9031 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9032 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9033 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9034 >  cat >>confdefs.h <<_ACEOF
9035 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9036 > _ACEOF
9037 >
9038 > else
9039 >  # strftime is in -lintl on SCO UNIX.
9040 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9041 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9042 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9043 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9044 > else
9045 >  ac_check_lib_save_LIBS=$LIBS
9046 > LIBS="-lintl  $LIBS"
9047 > cat >conftest.$ac_ext <<_ACEOF
9048 > /* confdefs.h.  */
9049 > _ACEOF
9050 > cat confdefs.h >>conftest.$ac_ext
9051 > cat >>conftest.$ac_ext <<_ACEOF
9052 > /* end confdefs.h.  */
9053 >
9054 > /* Override any gcc2 internal prototype to avoid an error.  */
9055 > #ifdef __cplusplus
9056 > extern "C"
9057 > #endif
9058 > /* We use char because int might match the return type of a gcc2
9059 >   builtin and then its argument prototype would still apply.  */
9060 > char strftime ();
9061 > #ifdef FC_DUMMY_MAIN
9062 > #ifndef FC_DUMMY_MAIN_EQ_F77
9063 > #  ifdef __cplusplus
9064 >     extern "C"
9065 > #  endif
9066 >   int FC_DUMMY_MAIN() { return 1; }
9067 > #endif
9068 > #endif
9069 > int
9070 > main ()
9071 > {
9072 > strftime ();
9073 >  ;
9074 >  return 0;
9075 > }
9076 > _ACEOF
9077 > rm -f conftest.$ac_objext conftest$ac_exeext
9078 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9079 >  (eval $ac_link) 2>conftest.er1
9080 >  ac_status=$?
9081 >  grep -v '^ *+' conftest.er1 >conftest.err
9082 >  rm -f conftest.er1
9083 >  cat conftest.err >&5
9084 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9085 >  (exit $ac_status); } &&
9086 >         { ac_try='test -z "$ac_c_werror_flag"
9087 >                         || test ! -s conftest.err'
9088 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9089 >  (eval $ac_try) 2>&5
9090 >  ac_status=$?
9091 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9092 >  (exit $ac_status); }; } &&
9093 >         { ac_try='test -s conftest$ac_exeext'
9094 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9095 >  (eval $ac_try) 2>&5
9096 >  ac_status=$?
9097 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9098 >  (exit $ac_status); }; }; then
9099 >  ac_cv_lib_intl_strftime=yes
9100 > else
9101 >  echo "$as_me: failed program was:" >&5
9102 > sed 's/^/| /' conftest.$ac_ext >&5
9103 >
9104 > ac_cv_lib_intl_strftime=no
9105 > fi
9106 > rm -f conftest.err conftest.$ac_objext \
9107 >      conftest$ac_exeext conftest.$ac_ext
9108 > LIBS=$ac_check_lib_save_LIBS
9109 > fi
9110 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9111 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9112 > if test $ac_cv_lib_intl_strftime = yes; then
9113 >  cat >>confdefs.h <<\_ACEOF
9114 > #define HAVE_STRFTIME 1
9115 > _ACEOF
9116 >
9117 > LIBS="-lintl $LIBS"
9118 > fi
9119 >
9120 > fi
9121 > done
9122 >
9123 > echo "$as_me:$LINENO: checking for working strtod" >&5
9124 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9125 > if test "${ac_cv_func_strtod+set}" = set; then
9126 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9127 > else
9128 >  if test "$cross_compiling" = yes; then
9129 >  ac_cv_func_strtod=no
9130 > else
9131 >  cat >conftest.$ac_ext <<_ACEOF
9132 > /* confdefs.h.  */
9133 > _ACEOF
9134 > cat confdefs.h >>conftest.$ac_ext
9135 > cat >>conftest.$ac_ext <<_ACEOF
9136 > /* end confdefs.h.  */
9137 >
9138 > double strtod ();
9139 > int
9140 > main()
9141 > {
9142 >  {
9143 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9144 >    char *string = " +69";
9145 >    char *term;
9146 >    double value;
9147 >    value = strtod (string, &term);
9148 >    if (value != 69 || term != (string + 4))
9149 >      exit (1);
9150 >  }
9151 >
9152 >  {
9153 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9154 >       terminating character under some conditions.  */
9155 >    char *string = "NaN";
9156 >    char *term;
9157 >    strtod (string, &term);
9158 >    if (term != string && *(term - 1) == 0)
9159 >      exit (1);
9160 >  }
9161 >  exit (0);
9162 > }
9163 >
9164 > _ACEOF
9165 > rm -f conftest$ac_exeext
9166 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9167 >  (eval $ac_link) 2>&5
9168 >  ac_status=$?
9169 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9170 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9171 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9172 >  (eval $ac_try) 2>&5
9173 >  ac_status=$?
9174 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9175 >  (exit $ac_status); }; }; then
9176 >  ac_cv_func_strtod=yes
9177 > else
9178 >  echo "$as_me: program exited with status $ac_status" >&5
9179 > echo "$as_me: failed program was:" >&5
9180 > sed 's/^/| /' conftest.$ac_ext >&5
9181 >
9182 > ( exit $ac_status )
9183 > ac_cv_func_strtod=no
9184 > fi
9185 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9186 > fi
9187 > fi
9188 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9189 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9190 > if test $ac_cv_func_strtod = no; then
9191 >  case $LIBOBJS in
9192 >    "strtod.$ac_objext"   | \
9193 >  *" strtod.$ac_objext"   | \
9194 >    "strtod.$ac_objext "* | \
9195 >  *" strtod.$ac_objext "* ) ;;
9196 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9197 > esac
9198 >
9199 > echo "$as_me:$LINENO: checking for pow" >&5
9200 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9201 > if test "${ac_cv_func_pow+set}" = set; then
9202 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9203 > else
9204 >  cat >conftest.$ac_ext <<_ACEOF
9205 > /* confdefs.h.  */
9206 > _ACEOF
9207 > cat confdefs.h >>conftest.$ac_ext
9208 > cat >>conftest.$ac_ext <<_ACEOF
9209 > /* end confdefs.h.  */
9210 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9211 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9212 > #define pow innocuous_pow
9213 >
9214 > /* System header to define __stub macros and hopefully few prototypes,
9215 >    which can conflict with char pow (); below.
9216 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9217 >    <limits.h> exists even on freestanding compilers.  */
9218 >
9219 > #ifdef __STDC__
9220 > # include <limits.h>
9221 > #else
9222 > # include <assert.h>
9223 > #endif
9224 >
9225 > #undef pow
9226 >
9227 > /* Override any gcc2 internal prototype to avoid an error.  */
9228 > #ifdef __cplusplus
9229 > extern "C"
9230 > {
9231 > #endif
9232 > /* We use char because int might match the return type of a gcc2
9233 >   builtin and then its argument prototype would still apply.  */
9234 > char pow ();
9235 > /* The GNU C library defines this for functions which it implements
9236 >    to always fail with ENOSYS.  Some functions are actually named
9237 >    something starting with __ and the normal name is an alias.  */
9238 > #if defined (__stub_pow) || defined (__stub___pow)
9239 > choke me
9240 > #else
9241 > char (*f) () = pow;
9242 > #endif
9243 > #ifdef __cplusplus
9244 > }
9245 > #endif
9246 >
9247 > #ifdef FC_DUMMY_MAIN
9248 > #ifndef FC_DUMMY_MAIN_EQ_F77
9249 > #  ifdef __cplusplus
9250 >     extern "C"
9251 > #  endif
9252 >   int FC_DUMMY_MAIN() { return 1; }
9253 > #endif
9254 > #endif
9255 > int
9256 > main ()
9257 > {
9258 > return f != pow;
9259 >  ;
9260 >  return 0;
9261 > }
9262 > _ACEOF
9263 > rm -f conftest.$ac_objext conftest$ac_exeext
9264 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9265 >  (eval $ac_link) 2>conftest.er1
9266 >  ac_status=$?
9267 >  grep -v '^ *+' conftest.er1 >conftest.err
9268 >  rm -f conftest.er1
9269 >  cat conftest.err >&5
9270 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9271 >  (exit $ac_status); } &&
9272 >         { ac_try='test -z "$ac_c_werror_flag"
9273 >                         || test ! -s conftest.err'
9274 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9275 >  (eval $ac_try) 2>&5
9276 >  ac_status=$?
9277 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9278 >  (exit $ac_status); }; } &&
9279 >         { ac_try='test -s conftest$ac_exeext'
9280 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9281 >  (eval $ac_try) 2>&5
9282 >  ac_status=$?
9283 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9284 >  (exit $ac_status); }; }; then
9285 >  ac_cv_func_pow=yes
9286 > else
9287 >  echo "$as_me: failed program was:" >&5
9288 > sed 's/^/| /' conftest.$ac_ext >&5
9289 >
9290 > ac_cv_func_pow=no
9291 > fi
9292 > rm -f conftest.err conftest.$ac_objext \
9293 >      conftest$ac_exeext conftest.$ac_ext
9294 > fi
9295 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9296 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9297 >
9298 > if test $ac_cv_func_pow = no; then
9299 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9300 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9301 > if test "${ac_cv_lib_m_pow+set}" = set; then
9302 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9303 > else
9304 >  ac_check_lib_save_LIBS=$LIBS
9305 > LIBS="-lm  $LIBS"
9306 > cat >conftest.$ac_ext <<_ACEOF
9307 > /* confdefs.h.  */
9308 > _ACEOF
9309 > cat confdefs.h >>conftest.$ac_ext
9310 > cat >>conftest.$ac_ext <<_ACEOF
9311 > /* end confdefs.h.  */
9312 >
9313 > /* Override any gcc2 internal prototype to avoid an error.  */
9314 > #ifdef __cplusplus
9315 > extern "C"
9316 > #endif
9317 > /* We use char because int might match the return type of a gcc2
9318 >   builtin and then its argument prototype would still apply.  */
9319 > char pow ();
9320 > #ifdef FC_DUMMY_MAIN
9321 > #ifndef FC_DUMMY_MAIN_EQ_F77
9322 > #  ifdef __cplusplus
9323 >     extern "C"
9324 > #  endif
9325 >   int FC_DUMMY_MAIN() { return 1; }
9326 > #endif
9327 > #endif
9328 > int
9329 > main ()
9330 > {
9331 > pow ();
9332 >  ;
9333 >  return 0;
9334 > }
9335 > _ACEOF
9336 > rm -f conftest.$ac_objext conftest$ac_exeext
9337 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9338 >  (eval $ac_link) 2>conftest.er1
9339 >  ac_status=$?
9340 >  grep -v '^ *+' conftest.er1 >conftest.err
9341 >  rm -f conftest.er1
9342 >  cat conftest.err >&5
9343 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9344 >  (exit $ac_status); } &&
9345 >         { ac_try='test -z "$ac_c_werror_flag"
9346 >                         || test ! -s conftest.err'
9347 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9348 >  (eval $ac_try) 2>&5
9349 >  ac_status=$?
9350 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9351 >  (exit $ac_status); }; } &&
9352 >         { ac_try='test -s conftest$ac_exeext'
9353 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9354 >  (eval $ac_try) 2>&5
9355 >  ac_status=$?
9356 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9357 >  (exit $ac_status); }; }; then
9358 >  ac_cv_lib_m_pow=yes
9359 > else
9360 >  echo "$as_me: failed program was:" >&5
9361 > sed 's/^/| /' conftest.$ac_ext >&5
9362 >
9363 > ac_cv_lib_m_pow=no
9364 > fi
9365 > rm -f conftest.err conftest.$ac_objext \
9366 >      conftest$ac_exeext conftest.$ac_ext
9367 > LIBS=$ac_check_lib_save_LIBS
9368 > fi
9369 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9370 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9371 > if test $ac_cv_lib_m_pow = yes; then
9372 >  POW_LIB=-lm
9373 > else
9374 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9375 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9376 > fi
9377 >
9378 > fi
9379 >
9380 > fi
9381 >
9382 >
9383 >
9384 >
9385 >
9386 >
9387 >
9388 >
9389 >
9390 >
9391 >
9392 >
9393 >
9394 >
9395 >
9396 >
9397 >
9398 >
9399 >
9400 >
9401 >
9402 >
9403 >
9404 >
9405 >
9406 >
9407 >
9408 >
9409 > 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
9410 > do
9411 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9412 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9413 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9414 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9415 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9416 > else
9417 >  cat >conftest.$ac_ext <<_ACEOF
9418 > /* confdefs.h.  */
9419 > _ACEOF
9420 > cat confdefs.h >>conftest.$ac_ext
9421 > cat >>conftest.$ac_ext <<_ACEOF
9422 > /* end confdefs.h.  */
9423 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9424 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9425 > #define $ac_func innocuous_$ac_func
9426 >
9427 > /* System header to define __stub macros and hopefully few prototypes,
9428 >    which can conflict with char $ac_func (); below.
9429 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9430 >    <limits.h> exists even on freestanding compilers.  */
9431 >
9432 > #ifdef __STDC__
9433 > # include <limits.h>
9434 > #else
9435 > # include <assert.h>
9436 > #endif
9437 >
9438 > #undef $ac_func
9439 >
9440 > /* Override any gcc2 internal prototype to avoid an error.  */
9441 > #ifdef __cplusplus
9442 > extern "C"
9443 > {
9444 > #endif
9445 > /* We use char because int might match the return type of a gcc2
9446 >   builtin and then its argument prototype would still apply.  */
9447 > char $ac_func ();
9448 > /* The GNU C library defines this for functions which it implements
9449 >    to always fail with ENOSYS.  Some functions are actually named
9450 >    something starting with __ and the normal name is an alias.  */
9451 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9452 > choke me
9453 > #else
9454 > char (*f) () = $ac_func;
9455 > #endif
9456 > #ifdef __cplusplus
9457 > }
9458 > #endif
9459 >
9460 > #ifdef FC_DUMMY_MAIN
9461 > #ifndef FC_DUMMY_MAIN_EQ_F77
9462 > #  ifdef __cplusplus
9463 >     extern "C"
9464 > #  endif
9465 >   int FC_DUMMY_MAIN() { return 1; }
9466 > #endif
9467 > #endif
9468 > int
9469 > main ()
9470 > {
9471 > return f != $ac_func;
9472 >  ;
9473 >  return 0;
9474 > }
9475 > _ACEOF
9476 > rm -f conftest.$ac_objext conftest$ac_exeext
9477 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9478 >  (eval $ac_link) 2>conftest.er1
9479 >  ac_status=$?
9480 >  grep -v '^ *+' conftest.er1 >conftest.err
9481 >  rm -f conftest.er1
9482 >  cat conftest.err >&5
9483 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9484 >  (exit $ac_status); } &&
9485 >         { ac_try='test -z "$ac_c_werror_flag"
9486 >                         || test ! -s conftest.err'
9487 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9488 >  (eval $ac_try) 2>&5
9489 >  ac_status=$?
9490 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9491 >  (exit $ac_status); }; } &&
9492 >         { ac_try='test -s conftest$ac_exeext'
9493 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9494 >  (eval $ac_try) 2>&5
9495 >  ac_status=$?
9496 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9497 >  (exit $ac_status); }; }; then
9498 >  eval "$as_ac_var=yes"
9499 > else
9500 >  echo "$as_me: failed program was:" >&5
9501 > sed 's/^/| /' conftest.$ac_ext >&5
9502 >
9503 > eval "$as_ac_var=no"
9504 > fi
9505 > rm -f conftest.err conftest.$ac_objext \
9506 >      conftest$ac_exeext conftest.$ac_ext
9507 > fi
9508 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9509 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9510 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9511 >  cat >>confdefs.h <<_ACEOF
9512 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9513 > _ACEOF
9514 >
9515 > fi
9516 > done
9517 >
9518 >
9519 > # special check for _system_configuration because AIX <4.3.2 do not
9520 > # contain the `physmem' member.
9521 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9522 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9523 > cat >conftest.$ac_ext <<_ACEOF
9524 > /* confdefs.h.  */
9525 > _ACEOF
9526 > cat confdefs.h >>conftest.$ac_ext
9527 > cat >>conftest.$ac_ext <<_ACEOF
9528 > /* end confdefs.h.  */
9529 > #include <sys/systemcfg.h>
9530 > #ifdef FC_DUMMY_MAIN
9531 > #ifndef FC_DUMMY_MAIN_EQ_F77
9532 > #  ifdef __cplusplus
9533 >     extern "C"
9534 > #  endif
9535 >   int FC_DUMMY_MAIN() { return 1; }
9536 > #endif
9537 > #endif
9538 > int
9539 > main ()
9540 > {
9541 > double x = _system_configuration.physmem;
9542 >  ;
9543 >  return 0;
9544 > }
9545 > _ACEOF
9546 > rm -f conftest.$ac_objext
9547 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9548 >  (eval $ac_compile) 2>conftest.er1
9549 >  ac_status=$?
9550 >  grep -v '^ *+' conftest.er1 >conftest.err
9551 >  rm -f conftest.er1
9552 >  cat conftest.err >&5
9553 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9554 >  (exit $ac_status); } &&
9555 >         { ac_try='test -z "$ac_c_werror_flag"
9556 >                         || test ! -s conftest.err'
9557 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9558 >  (eval $ac_try) 2>&5
9559 >  ac_status=$?
9560 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9561 >  (exit $ac_status); }; } &&
9562 >         { ac_try='test -s conftest.$ac_objext'
9563 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9564 >  (eval $ac_try) 2>&5
9565 >  ac_status=$?
9566 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9567 >  (exit $ac_status); }; }; then
9568 >  echo "$as_me:$LINENO: result: yes" >&5
9569 > echo "${ECHO_T}yes" >&6
9570 >
9571 > cat >>confdefs.h <<\_ACEOF
9572 > #define HAVE__SYSTEM_CONFIGURATION 1
9573 > _ACEOF
9574 >
9575 > else
9576 >  echo "$as_me: failed program was:" >&5
9577 > sed 's/^/| /' conftest.$ac_ext >&5
9578 >
9579 > echo "$as_me:$LINENO: result: no" >&5
9580 > echo "${ECHO_T}no" >&6
9581 > fi
9582 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9583 >
9584 >  # clean out junk possibly left behind by a previous configuration
9585 >  rm -f src/getopt.h
9586 >  # Check for getopt_long support
9587 >
9588 > for ac_header in getopt.h
9589 > do
9590 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9591 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9592 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9593 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9594 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9595 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9596 > fi
9597 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9598 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9599 > else
9600 >  # Is the header compilable?
9601 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9602 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9603 > cat >conftest.$ac_ext <<_ACEOF
9604 > /* confdefs.h.  */
9605 > _ACEOF
9606 > cat confdefs.h >>conftest.$ac_ext
9607 > cat >>conftest.$ac_ext <<_ACEOF
9608 > /* end confdefs.h.  */
9609 > $ac_includes_default
9610 > #include <$ac_header>
9611 > _ACEOF
9612 > rm -f conftest.$ac_objext
9613 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9614 >  (eval $ac_compile) 2>conftest.er1
9615 >  ac_status=$?
9616 >  grep -v '^ *+' conftest.er1 >conftest.err
9617 >  rm -f conftest.er1
9618 >  cat conftest.err >&5
9619 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9620 >  (exit $ac_status); } &&
9621 >         { ac_try='test -z "$ac_c_werror_flag"
9622 >                         || test ! -s conftest.err'
9623 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9624 >  (eval $ac_try) 2>&5
9625 >  ac_status=$?
9626 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9627 >  (exit $ac_status); }; } &&
9628 >         { ac_try='test -s conftest.$ac_objext'
9629 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9630 >  (eval $ac_try) 2>&5
9631 >  ac_status=$?
9632 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9633 >  (exit $ac_status); }; }; then
9634 >  ac_header_compiler=yes
9635 > else
9636 >  echo "$as_me: failed program was:" >&5
9637 > sed 's/^/| /' conftest.$ac_ext >&5
9638 >
9639 > ac_header_compiler=no
9640 > fi
9641 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9642 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9643 > echo "${ECHO_T}$ac_header_compiler" >&6
9644 >
9645 > # Is the header present?
9646 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9647 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9648 > cat >conftest.$ac_ext <<_ACEOF
9649 > /* confdefs.h.  */
9650 > _ACEOF
9651 > cat confdefs.h >>conftest.$ac_ext
9652 > cat >>conftest.$ac_ext <<_ACEOF
9653 > /* end confdefs.h.  */
9654 > #include <$ac_header>
9655 > _ACEOF
9656 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9657 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9658 >  ac_status=$?
9659 >  grep -v '^ *+' conftest.er1 >conftest.err
9660 >  rm -f conftest.er1
9661 >  cat conftest.err >&5
9662 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9663 >  (exit $ac_status); } >/dev/null; then
9664 >  if test -s conftest.err; then
9665 >    ac_cpp_err=$ac_c_preproc_warn_flag
9666 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9667 >  else
9668 >    ac_cpp_err=
9669 >  fi
9670 > else
9671 >  ac_cpp_err=yes
9672 > fi
9673 > if test -z "$ac_cpp_err"; then
9674 >  ac_header_preproc=yes
9675 > else
9676 >  echo "$as_me: failed program was:" >&5
9677 > sed 's/^/| /' conftest.$ac_ext >&5
9678 >
9679 >  ac_header_preproc=no
9680 > fi
9681 > rm -f conftest.err conftest.$ac_ext
9682 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9683 > echo "${ECHO_T}$ac_header_preproc" >&6
9684 >
9685 > # So?  What about this header?
9686 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9687 >  yes:no: )
9688 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9689 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9690 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9691 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9692 >    ac_header_preproc=yes
9693 >    ;;
9694 >  no:yes:* )
9695 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9696 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9697 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9698 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9699 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9700 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9701 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9702 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9703 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9704 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9705 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9706 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9707 >    (
9708 >      cat <<\_ASBOX
9709 > ## ------------------------------ ##
9710 > ## Report this to gezelter@nd.edu ##
9711 > ## ------------------------------ ##
9712 > _ASBOX
9713 >    ) |
9714 >      sed "s/^/$as_me: WARNING:     /" >&2
9715 >    ;;
9716 > esac
9717 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9718 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9719 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9720 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9721 > else
9722 >  eval "$as_ac_Header=\$ac_header_preproc"
9723 > fi
9724 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9725 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9726 >
9727 > fi
9728 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9729 >  cat >>confdefs.h <<_ACEOF
9730 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9731 > _ACEOF
9732 >
9733 > fi
9734 >
9735 > done
9736 >
9737 >
9738 > for ac_func in getopt_long
9739 > do
9740 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9741 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9742 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9743 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9744 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9745 > else
9746 >  cat >conftest.$ac_ext <<_ACEOF
9747 > /* confdefs.h.  */
9748 > _ACEOF
9749 > cat confdefs.h >>conftest.$ac_ext
9750 > cat >>conftest.$ac_ext <<_ACEOF
9751 > /* end confdefs.h.  */
9752 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9753 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9754 > #define $ac_func innocuous_$ac_func
9755 >
9756 > /* System header to define __stub macros and hopefully few prototypes,
9757 >    which can conflict with char $ac_func (); below.
9758 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9759 >    <limits.h> exists even on freestanding compilers.  */
9760 >
9761 > #ifdef __STDC__
9762 > # include <limits.h>
9763 > #else
9764 > # include <assert.h>
9765 > #endif
9766 >
9767 > #undef $ac_func
9768 >
9769 > /* Override any gcc2 internal prototype to avoid an error.  */
9770 > #ifdef __cplusplus
9771 > extern "C"
9772 > {
9773 > #endif
9774 > /* We use char because int might match the return type of a gcc2
9775 >   builtin and then its argument prototype would still apply.  */
9776 > char $ac_func ();
9777 > /* The GNU C library defines this for functions which it implements
9778 >    to always fail with ENOSYS.  Some functions are actually named
9779 >    something starting with __ and the normal name is an alias.  */
9780 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9781 > choke me
9782 > #else
9783 > char (*f) () = $ac_func;
9784 > #endif
9785 > #ifdef __cplusplus
9786 > }
9787 > #endif
9788 >
9789 > #ifdef FC_DUMMY_MAIN
9790 > #ifndef FC_DUMMY_MAIN_EQ_F77
9791 > #  ifdef __cplusplus
9792 >     extern "C"
9793 > #  endif
9794 >   int FC_DUMMY_MAIN() { return 1; }
9795 > #endif
9796 > #endif
9797 > int
9798 > main ()
9799 > {
9800 > return f != $ac_func;
9801 >  ;
9802 >  return 0;
9803 > }
9804 > _ACEOF
9805 > rm -f conftest.$ac_objext conftest$ac_exeext
9806 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9807 >  (eval $ac_link) 2>conftest.er1
9808 >  ac_status=$?
9809 >  grep -v '^ *+' conftest.er1 >conftest.err
9810 >  rm -f conftest.er1
9811 >  cat conftest.err >&5
9812 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9813 >  (exit $ac_status); } &&
9814 >         { ac_try='test -z "$ac_c_werror_flag"
9815 >                         || test ! -s conftest.err'
9816 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9817 >  (eval $ac_try) 2>&5
9818 >  ac_status=$?
9819 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9820 >  (exit $ac_status); }; } &&
9821 >         { ac_try='test -s conftest$ac_exeext'
9822 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9823 >  (eval $ac_try) 2>&5
9824 >  ac_status=$?
9825 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9826 >  (exit $ac_status); }; }; then
9827 >  eval "$as_ac_var=yes"
9828 > else
9829 >  echo "$as_me: failed program was:" >&5
9830 > sed 's/^/| /' conftest.$ac_ext >&5
9831 >
9832 > eval "$as_ac_var=no"
9833 > fi
9834 > rm -f conftest.err conftest.$ac_objext \
9835 >      conftest$ac_exeext conftest.$ac_ext
9836 > fi
9837 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9838 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9839 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9840 >  cat >>confdefs.h <<_ACEOF
9841 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9842 > _ACEOF
9843 >
9844 > else
9845 >  # FreeBSD has a gnugetopt library for this
9846 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
9847 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
9848 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
9849 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9850 > else
9851 >  ac_check_lib_save_LIBS=$LIBS
9852 > LIBS="-lgnugetopt  $LIBS"
9853 > cat >conftest.$ac_ext <<_ACEOF
9854 > /* confdefs.h.  */
9855 > _ACEOF
9856 > cat confdefs.h >>conftest.$ac_ext
9857 > cat >>conftest.$ac_ext <<_ACEOF
9858 > /* end confdefs.h.  */
9859 >
9860 > /* Override any gcc2 internal prototype to avoid an error.  */
9861 > #ifdef __cplusplus
9862 > extern "C"
9863 > #endif
9864 > /* We use char because int might match the return type of a gcc2
9865 >   builtin and then its argument prototype would still apply.  */
9866 > char getopt_long ();
9867 > #ifdef FC_DUMMY_MAIN
9868 > #ifndef FC_DUMMY_MAIN_EQ_F77
9869 > #  ifdef __cplusplus
9870 >     extern "C"
9871 > #  endif
9872 >   int FC_DUMMY_MAIN() { return 1; }
9873 > #endif
9874 > #endif
9875 > int
9876 > main ()
9877 > {
9878 > getopt_long ();
9879 >  ;
9880 >  return 0;
9881 > }
9882 > _ACEOF
9883 > rm -f conftest.$ac_objext conftest$ac_exeext
9884 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9885 >  (eval $ac_link) 2>conftest.er1
9886 >  ac_status=$?
9887 >  grep -v '^ *+' conftest.er1 >conftest.err
9888 >  rm -f conftest.er1
9889 >  cat conftest.err >&5
9890 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9891 >  (exit $ac_status); } &&
9892 >         { ac_try='test -z "$ac_c_werror_flag"
9893 >                         || test ! -s conftest.err'
9894 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9895 >  (eval $ac_try) 2>&5
9896 >  ac_status=$?
9897 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9898 >  (exit $ac_status); }; } &&
9899 >         { ac_try='test -s conftest$ac_exeext'
9900 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9901 >  (eval $ac_try) 2>&5
9902 >  ac_status=$?
9903 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9904 >  (exit $ac_status); }; }; then
9905 >  ac_cv_lib_gnugetopt_getopt_long=yes
9906 > else
9907 >  echo "$as_me: failed program was:" >&5
9908 > sed 's/^/| /' conftest.$ac_ext >&5
9909 >
9910 > ac_cv_lib_gnugetopt_getopt_long=no
9911 > fi
9912 > rm -f conftest.err conftest.$ac_objext \
9913 >      conftest$ac_exeext conftest.$ac_ext
9914 > LIBS=$ac_check_lib_save_LIBS
9915 > fi
9916 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
9917 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
9918 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
9919 >  cat >>confdefs.h <<\_ACEOF
9920 > #define HAVE_GETOPT_LONG 1
9921 > _ACEOF
9922 >
9923 > else
9924 >  # use the GNU replacement
9925 >      case $LIBOBJS in
9926 >    "getopt.$ac_objext"   | \
9927 >  *" getopt.$ac_objext"   | \
9928 >    "getopt.$ac_objext "* | \
9929 >  *" getopt.$ac_objext "* ) ;;
9930 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
9931 > esac
9932 >
9933 >      case $LIBOBJS in
9934 >    "getopt1.$ac_objext"   | \
9935 >  *" getopt1.$ac_objext"   | \
9936 >    "getopt1.$ac_objext "* | \
9937 >  *" getopt1.$ac_objext "* ) ;;
9938 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
9939 > esac
9940 >
9941 >                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
9942 >
9943 > fi
9944 >
9945 > fi
9946 > done
9947 >
9948 >
9949 > ac_ext=cc
9950 > ac_cpp='$CXXCPP $CPPFLAGS'
9951 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9952 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9953 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9954 >
9955 >
9956 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
9957 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
9958 > if test "${ac_cv_cxx_namespaces+set}" = set; then
9959 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9960 > else
9961 >
9962 >
9963 > ac_ext=cc
9964 > ac_cpp='$CXXCPP $CPPFLAGS'
9965 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9966 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9967 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9968 >
9969 > cat >conftest.$ac_ext <<_ACEOF
9970 > /* confdefs.h.  */
9971 > _ACEOF
9972 > cat confdefs.h >>conftest.$ac_ext
9973 > cat >>conftest.$ac_ext <<_ACEOF
9974 > /* end confdefs.h.  */
9975 > namespace Outer { namespace Inner { int i = 0; }}
9976 > #ifdef FC_DUMMY_MAIN
9977 > #ifndef FC_DUMMY_MAIN_EQ_F77
9978 > #  ifdef __cplusplus
9979 >     extern "C"
9980 > #  endif
9981 >   int FC_DUMMY_MAIN() { return 1; }
9982 > #endif
9983 > #endif
9984 > int
9985 > main ()
9986 > {
9987 > using namespace Outer::Inner; return i;
9988 >  ;
9989 >  return 0;
9990 > }
9991 > _ACEOF
9992 > rm -f conftest.$ac_objext
9993 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9994 >  (eval $ac_compile) 2>conftest.er1
9995 >  ac_status=$?
9996 >  grep -v '^ *+' conftest.er1 >conftest.err
9997 >  rm -f conftest.er1
9998 >  cat conftest.err >&5
9999 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10000 >  (exit $ac_status); } &&
10001 >         { ac_try='test -z "$ac_cxx_werror_flag"
10002 >                         || test ! -s conftest.err'
10003 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10004 >  (eval $ac_try) 2>&5
10005 >  ac_status=$?
10006 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10007 >  (exit $ac_status); }; } &&
10008 >         { ac_try='test -s conftest.$ac_objext'
10009 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10010 >  (eval $ac_try) 2>&5
10011 >  ac_status=$?
10012 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10013 >  (exit $ac_status); }; }; then
10014 >  ac_cv_cxx_namespaces=yes
10015 > else
10016 >  echo "$as_me: failed program was:" >&5
10017 > sed 's/^/| /' conftest.$ac_ext >&5
10018 >
10019 > ac_cv_cxx_namespaces=no
10020 > fi
10021 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10022 > ac_ext=cc
10023 > ac_cpp='$CXXCPP $CPPFLAGS'
10024 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10025 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10026 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10027 >
10028 >
10029 > fi
10030 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10031 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10032 > if test "$ac_cv_cxx_namespaces" = yes; then
10033 >
10034 > cat >>confdefs.h <<\_ACEOF
10035 > #define HAVE_NAMESPACES
10036 > _ACEOF
10037 >
10038 > fi
10039 >
10040 > ac_ext=cc
10041 > ac_cpp='$CXXCPP $CPPFLAGS'
10042 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10043 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10044 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10045 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10046 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10047 > if test -z "$CXXCPP"; then
10048 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10049 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10050 > else
10051 >      # Double quotes because CXXCPP needs to be expanded
10052 >    for CXXCPP in "$CXX -E" "/lib/cpp"
10053 >    do
10054 >      ac_preproc_ok=false
10055 > for ac_cxx_preproc_warn_flag in '' yes
10056 > do
10057 >  # Use a header file that comes with gcc, so configuring glibc
10058 >  # with a fresh cross-compiler works.
10059 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10060 >  # <limits.h> exists even on freestanding compilers.
10061 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10062 >  # not just through cpp. "Syntax error" is here to catch this case.
10063 >  cat >conftest.$ac_ext <<_ACEOF
10064 > /* confdefs.h.  */
10065 > _ACEOF
10066 > cat confdefs.h >>conftest.$ac_ext
10067 > cat >>conftest.$ac_ext <<_ACEOF
10068 > /* end confdefs.h.  */
10069 > #ifdef __STDC__
10070 > # include <limits.h>
10071 > #else
10072 > # include <assert.h>
10073 > #endif
10074 >                     Syntax error
10075 > _ACEOF
10076 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10077 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10078 >  ac_status=$?
10079 >  grep -v '^ *+' conftest.er1 >conftest.err
10080 >  rm -f conftest.er1
10081 >  cat conftest.err >&5
10082 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10083 >  (exit $ac_status); } >/dev/null; then
10084 >  if test -s conftest.err; then
10085 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10086 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10087 >  else
10088 >    ac_cpp_err=
10089 >  fi
10090 > else
10091 >  ac_cpp_err=yes
10092 > fi
10093 > if test -z "$ac_cpp_err"; then
10094 >  :
10095 > else
10096 >  echo "$as_me: failed program was:" >&5
10097 > sed 's/^/| /' conftest.$ac_ext >&5
10098 >
10099 >  # Broken: fails on valid input.
10100 > continue
10101 > fi
10102 > rm -f conftest.err conftest.$ac_ext
10103 >
10104 >  # OK, works on sane cases.  Now check whether non-existent headers
10105 >  # can be detected and how.
10106 >  cat >conftest.$ac_ext <<_ACEOF
10107 > /* confdefs.h.  */
10108 > _ACEOF
10109 > cat confdefs.h >>conftest.$ac_ext
10110 > cat >>conftest.$ac_ext <<_ACEOF
10111 > /* end confdefs.h.  */
10112 > #include <ac_nonexistent.h>
10113 > _ACEOF
10114 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10115 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10116 >  ac_status=$?
10117 >  grep -v '^ *+' conftest.er1 >conftest.err
10118 >  rm -f conftest.er1
10119 >  cat conftest.err >&5
10120 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10121 >  (exit $ac_status); } >/dev/null; then
10122 >  if test -s conftest.err; then
10123 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10124 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10125 >  else
10126 >    ac_cpp_err=
10127 >  fi
10128 > else
10129 >  ac_cpp_err=yes
10130 > fi
10131 > if test -z "$ac_cpp_err"; then
10132 >  # Broken: success on invalid input.
10133 > continue
10134 > else
10135 >  echo "$as_me: failed program was:" >&5
10136 > sed 's/^/| /' conftest.$ac_ext >&5
10137 >
10138 >  # Passes both tests.
10139 > ac_preproc_ok=:
10140 > break
10141 > fi
10142 > rm -f conftest.err conftest.$ac_ext
10143 >
10144 > done
10145 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10146 > rm -f conftest.err conftest.$ac_ext
10147 > if $ac_preproc_ok; then
10148 >  break
10149 > fi
10150 >
10151 >    done
10152 >    ac_cv_prog_CXXCPP=$CXXCPP
10153 >
10154 > fi
10155 >  CXXCPP=$ac_cv_prog_CXXCPP
10156 > else
10157 >  ac_cv_prog_CXXCPP=$CXXCPP
10158 > fi
10159 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10160 > echo "${ECHO_T}$CXXCPP" >&6
10161 > ac_preproc_ok=false
10162 > for ac_cxx_preproc_warn_flag in '' yes
10163   do
10164    # Use a header file that comes with gcc, so configuring glibc
10165    # with a fresh cross-compiler works.
# Line 4275 | Line 10168 | do
10168    # On the NeXT, cc -E runs the code through the compiler's parser,
10169    # not just through cpp. "Syntax error" is here to catch this case.
10170    cat >conftest.$ac_ext <<_ACEOF
4278 #line $LINENO "configure"
10171   /* confdefs.h.  */
10172   _ACEOF
10173   cat confdefs.h >>conftest.$ac_ext
# Line 4286 | Line 10178 | cat >>conftest.$ac_ext <<_ACEOF
10178   #else
10179   # include <assert.h>
10180   #endif
10181 <                     Syntax error
10181 >                     Syntax error
10182   _ACEOF
10183   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10184    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 4297 | Line 10189 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10189    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10190    (exit $ac_status); } >/dev/null; then
10191    if test -s conftest.err; then
10192 <    ac_cpp_err=$ac_c_preproc_warn_flag
10192 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10193 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10194    else
10195      ac_cpp_err=
10196    fi
# Line 4318 | Line 10211 | rm -f conftest.err conftest.$ac_ext
10211    # OK, works on sane cases.  Now check whether non-existent headers
10212    # can be detected and how.
10213    cat >conftest.$ac_ext <<_ACEOF
4321 #line $LINENO "configure"
10214   /* confdefs.h.  */
10215   _ACEOF
10216   cat confdefs.h >>conftest.$ac_ext
# Line 4335 | Line 10227 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10227    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10228    (exit $ac_status); } >/dev/null; then
10229    if test -s conftest.err; then
10230 <    ac_cpp_err=$ac_c_preproc_warn_flag
10230 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10231 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10232    else
10233      ac_cpp_err=
10234    fi
# Line 4359 | Line 10252 | if $ac_preproc_ok; then
10252   # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10253   rm -f conftest.err conftest.$ac_ext
10254   if $ac_preproc_ok; then
10255 <  break
10255 >  :
10256 > else
10257 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10258 > See \`config.log' for more details." >&5
10259 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10260 > See \`config.log' for more details." >&2;}
10261 >   { (exit 1); exit 1; }; }
10262   fi
10263  
10264 <    done
10265 <    ac_cv_prog_CPP=$CPP
10264 > ac_ext=cc
10265 > ac_cpp='$CXXCPP $CPPFLAGS'
10266 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10267 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10268 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10269  
10270 +
10271 + echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10272 + echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10273 + if test "${ac_cv_cxx_have_stl+set}" = set; then
10274 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10275 + else
10276 +
10277 +
10278 +
10279 + ac_ext=cc
10280 + ac_cpp='$CXXCPP $CPPFLAGS'
10281 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10282 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10283 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10284 +
10285 + cat >conftest.$ac_ext <<_ACEOF
10286 + /* confdefs.h.  */
10287 + _ACEOF
10288 + cat confdefs.h >>conftest.$ac_ext
10289 + cat >>conftest.$ac_ext <<_ACEOF
10290 + /* end confdefs.h.  */
10291 + #include <list>
10292 + #include <deque>
10293 + #ifdef HAVE_NAMESPACES
10294 + using namespace std;
10295 + #endif
10296 + #ifdef FC_DUMMY_MAIN
10297 + #ifndef FC_DUMMY_MAIN_EQ_F77
10298 + #  ifdef __cplusplus
10299 +     extern "C"
10300 + #  endif
10301 +   int FC_DUMMY_MAIN() { return 1; }
10302 + #endif
10303 + #endif
10304 + int
10305 + main ()
10306 + {
10307 + list<int> x; x.push_back(5);
10308 + list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10309 +  ;
10310 +  return 0;
10311 + }
10312 + _ACEOF
10313 + rm -f conftest.$ac_objext
10314 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10315 +  (eval $ac_compile) 2>conftest.er1
10316 +  ac_status=$?
10317 +  grep -v '^ *+' conftest.er1 >conftest.err
10318 +  rm -f conftest.er1
10319 +  cat conftest.err >&5
10320 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10321 +  (exit $ac_status); } &&
10322 +         { ac_try='test -z "$ac_cxx_werror_flag"
10323 +                         || test ! -s conftest.err'
10324 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10325 +  (eval $ac_try) 2>&5
10326 +  ac_status=$?
10327 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10328 +  (exit $ac_status); }; } &&
10329 +         { ac_try='test -s conftest.$ac_objext'
10330 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10331 +  (eval $ac_try) 2>&5
10332 +  ac_status=$?
10333 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10334 +  (exit $ac_status); }; }; then
10335 +  ac_cv_cxx_have_stl=yes
10336 + else
10337 +  echo "$as_me: failed program was:" >&5
10338 + sed 's/^/| /' conftest.$ac_ext >&5
10339 +
10340 + ac_cv_cxx_have_stl=no
10341   fi
10342 <  CPP=$ac_cv_prog_CPP
10342 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10343 > ac_ext=cc
10344 > ac_cpp='$CXXCPP $CPPFLAGS'
10345 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10346 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10347 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10348 >
10349 >
10350 > fi
10351 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10352 > echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10353 > if test "$ac_cv_cxx_have_stl" = yes; then
10354 >
10355 > cat >>confdefs.h <<\_ACEOF
10356 > #define HAVE_STL
10357 > _ACEOF
10358 >
10359 > fi
10360 >
10361 >
10362 >
10363 >  if test "${ac_cv_header_iostream+set}" = set; then
10364 >  echo "$as_me:$LINENO: checking for iostream" >&5
10365 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10366 > if test "${ac_cv_header_iostream+set}" = set; then
10367 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10368 > fi
10369 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10370 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10371   else
10372 <  ac_cv_prog_CPP=$CPP
10372 >  # Is the header compilable?
10373 > echo "$as_me:$LINENO: checking iostream usability" >&5
10374 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10375 > cat >conftest.$ac_ext <<_ACEOF
10376 > /* confdefs.h.  */
10377 > _ACEOF
10378 > cat confdefs.h >>conftest.$ac_ext
10379 > cat >>conftest.$ac_ext <<_ACEOF
10380 > /* end confdefs.h.  */
10381 > $ac_includes_default
10382 > #include <iostream>
10383 > _ACEOF
10384 > rm -f conftest.$ac_objext
10385 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10386 >  (eval $ac_compile) 2>conftest.er1
10387 >  ac_status=$?
10388 >  grep -v '^ *+' conftest.er1 >conftest.err
10389 >  rm -f conftest.er1
10390 >  cat conftest.err >&5
10391 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10392 >  (exit $ac_status); } &&
10393 >         { ac_try='test -z "$ac_cxx_werror_flag"
10394 >                         || test ! -s conftest.err'
10395 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10396 >  (eval $ac_try) 2>&5
10397 >  ac_status=$?
10398 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10399 >  (exit $ac_status); }; } &&
10400 >         { ac_try='test -s conftest.$ac_objext'
10401 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10402 >  (eval $ac_try) 2>&5
10403 >  ac_status=$?
10404 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10405 >  (exit $ac_status); }; }; then
10406 >  ac_header_compiler=yes
10407 > else
10408 >  echo "$as_me: failed program was:" >&5
10409 > sed 's/^/| /' conftest.$ac_ext >&5
10410 >
10411 > ac_header_compiler=no
10412   fi
10413 < echo "$as_me:$LINENO: result: $CPP" >&5
10414 < echo "${ECHO_T}$CPP" >&6
10415 < ac_preproc_ok=false
10416 < for ac_c_preproc_warn_flag in '' yes
10417 < do
10418 <  # Use a header file that comes with gcc, so configuring glibc
10419 <  # with a fresh cross-compiler works.
10420 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4381 <  # <limits.h> exists even on freestanding compilers.
4382 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4383 <  # not just through cpp. "Syntax error" is here to catch this case.
4384 <  cat >conftest.$ac_ext <<_ACEOF
4385 < #line $LINENO "configure"
10413 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10414 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10415 > echo "${ECHO_T}$ac_header_compiler" >&6
10416 >
10417 > # Is the header present?
10418 > echo "$as_me:$LINENO: checking iostream presence" >&5
10419 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10420 > cat >conftest.$ac_ext <<_ACEOF
10421   /* confdefs.h.  */
10422   _ACEOF
10423   cat confdefs.h >>conftest.$ac_ext
10424   cat >>conftest.$ac_ext <<_ACEOF
10425   /* end confdefs.h.  */
10426 < #ifdef __STDC__
4392 < # include <limits.h>
4393 < #else
4394 < # include <assert.h>
4395 < #endif
4396 <                     Syntax error
10426 > #include <iostream>
10427   _ACEOF
10428   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10429    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 4404 | Line 10434 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10434    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10435    (exit $ac_status); } >/dev/null; then
10436    if test -s conftest.err; then
10437 <    ac_cpp_err=$ac_c_preproc_warn_flag
10437 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10438 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10439    else
10440      ac_cpp_err=
10441    fi
# Line 4412 | Line 10443 | if test -z "$ac_cpp_err"; then
10443    ac_cpp_err=yes
10444   fi
10445   if test -z "$ac_cpp_err"; then
10446 <  :
10446 >  ac_header_preproc=yes
10447   else
10448    echo "$as_me: failed program was:" >&5
10449   sed 's/^/| /' conftest.$ac_ext >&5
10450  
10451 <  # Broken: fails on valid input.
4421 < continue
10451 >  ac_header_preproc=no
10452   fi
10453   rm -f conftest.err conftest.$ac_ext
10454 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10455 + echo "${ECHO_T}$ac_header_preproc" >&6
10456  
10457 <  # OK, works on sane cases.  Now check whether non-existent headers
10458 <  # can be detected and how.
10459 <  cat >conftest.$ac_ext <<_ACEOF
10460 < #line $LINENO "configure"
10457 > # So?  What about this header?
10458 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10459 >  yes:no: )
10460 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10461 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10462 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10463 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10464 >    ac_header_preproc=yes
10465 >    ;;
10466 >  no:yes:* )
10467 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10468 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10469 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10470 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10471 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10472 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10473 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10474 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10475 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10476 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10477 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10478 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10479 >    (
10480 >      cat <<\_ASBOX
10481 > ## ------------------------------ ##
10482 > ## Report this to gezelter@nd.edu ##
10483 > ## ------------------------------ ##
10484 > _ASBOX
10485 >    ) |
10486 >      sed "s/^/$as_me: WARNING:     /" >&2
10487 >    ;;
10488 > esac
10489 > echo "$as_me:$LINENO: checking for iostream" >&5
10490 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10491 > if test "${ac_cv_header_iostream+set}" = set; then
10492 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10493 > else
10494 >  ac_cv_header_iostream=$ac_header_preproc
10495 > fi
10496 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10497 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10498 >
10499 > fi
10500 > if test $ac_cv_header_iostream = yes; then
10501 >
10502 >
10503 > cat >>confdefs.h <<\_ACEOF
10504 > #define HAVE_IOSTREAM 1
10505 > _ACEOF
10506 >
10507 >
10508 > else
10509 >
10510 >
10511 > for ac_header in iostream.h
10512 > do
10513 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10514 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10515 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10516 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10517 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10518 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10519 > fi
10520 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10521 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10522 > else
10523 >  # Is the header compilable?
10524 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10525 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10526 > cat >conftest.$ac_ext <<_ACEOF
10527   /* confdefs.h.  */
10528   _ACEOF
10529   cat confdefs.h >>conftest.$ac_ext
10530   cat >>conftest.$ac_ext <<_ACEOF
10531   /* end confdefs.h.  */
10532 < #include <ac_nonexistent.h>
10532 > $ac_includes_default
10533 > #include <$ac_header>
10534   _ACEOF
10535 + rm -f conftest.$ac_objext
10536 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10537 +  (eval $ac_compile) 2>conftest.er1
10538 +  ac_status=$?
10539 +  grep -v '^ *+' conftest.er1 >conftest.err
10540 +  rm -f conftest.er1
10541 +  cat conftest.err >&5
10542 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10543 +  (exit $ac_status); } &&
10544 +         { ac_try='test -z "$ac_cxx_werror_flag"
10545 +                         || test ! -s conftest.err'
10546 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10547 +  (eval $ac_try) 2>&5
10548 +  ac_status=$?
10549 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10550 +  (exit $ac_status); }; } &&
10551 +         { ac_try='test -s conftest.$ac_objext'
10552 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10553 +  (eval $ac_try) 2>&5
10554 +  ac_status=$?
10555 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10556 +  (exit $ac_status); }; }; then
10557 +  ac_header_compiler=yes
10558 + else
10559 +  echo "$as_me: failed program was:" >&5
10560 + sed 's/^/| /' conftest.$ac_ext >&5
10561 +
10562 + ac_header_compiler=no
10563 + fi
10564 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10565 + echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10566 + echo "${ECHO_T}$ac_header_compiler" >&6
10567 +
10568 + # Is the header present?
10569 + echo "$as_me:$LINENO: checking $ac_header presence" >&5
10570 + echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10571 + cat >conftest.$ac_ext <<_ACEOF
10572 + /* confdefs.h.  */
10573 + _ACEOF
10574 + cat confdefs.h >>conftest.$ac_ext
10575 + cat >>conftest.$ac_ext <<_ACEOF
10576 + /* end confdefs.h.  */
10577 + #include <$ac_header>
10578 + _ACEOF
10579   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10580    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10581    ac_status=$?
# Line 4442 | Line 10585 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10585    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10586    (exit $ac_status); } >/dev/null; then
10587    if test -s conftest.err; then
10588 <    ac_cpp_err=$ac_c_preproc_warn_flag
10588 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10589 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10590    else
10591      ac_cpp_err=
10592    fi
# Line 4450 | Line 10594 | if test -z "$ac_cpp_err"; then
10594    ac_cpp_err=yes
10595   fi
10596   if test -z "$ac_cpp_err"; then
10597 <  # Broken: success on invalid input.
4454 < continue
10597 >  ac_header_preproc=yes
10598   else
10599    echo "$as_me: failed program was:" >&5
10600   sed 's/^/| /' conftest.$ac_ext >&5
10601  
10602 <  # Passes both tests.
4460 < ac_preproc_ok=:
4461 < break
10602 >  ac_header_preproc=no
10603   fi
10604   rm -f conftest.err conftest.$ac_ext
10605 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10606 + echo "${ECHO_T}$ac_header_preproc" >&6
10607  
10608 < done
10609 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10610 < rm -f conftest.err conftest.$ac_ext
10611 < if $ac_preproc_ok; then
10612 <  :
10608 > # So?  What about this header?
10609 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10610 >  yes:no: )
10611 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10612 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10613 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10614 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10615 >    ac_header_preproc=yes
10616 >    ;;
10617 >  no:yes:* )
10618 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10619 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10620 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10621 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10622 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10623 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10624 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10625 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10626 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10627 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10628 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10629 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10630 >    (
10631 >      cat <<\_ASBOX
10632 > ## ------------------------------ ##
10633 > ## Report this to gezelter@nd.edu ##
10634 > ## ------------------------------ ##
10635 > _ASBOX
10636 >    ) |
10637 >      sed "s/^/$as_me: WARNING:     /" >&2
10638 >    ;;
10639 > esac
10640 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10641 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10642 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10643 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10644   else
10645 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4472 < See \`config.log' for more details." >&5
4473 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4474 < See \`config.log' for more details." >&2;}
4475 <   { (exit 1); exit 1; }; }
10645 >  eval "$as_ac_Header=\$ac_header_preproc"
10646   fi
10647 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10648 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10649  
10650 < ac_ext=c
10651 < ac_cpp='$CPP $CPPFLAGS'
10652 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10653 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10654 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
10650 > fi
10651 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10652 >  cat >>confdefs.h <<_ACEOF
10653 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10654 > _ACEOF
10655  
10656 + fi
10657  
10658 < echo "$as_me:$LINENO: checking for egrep" >&5
10659 < echo $ECHO_N "checking for egrep... $ECHO_C" >&6
10660 < if test "${ac_cv_prog_egrep+set}" = set; then
4488 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4489 < 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
10658 > done
10659 >
10660 >
10661   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
10662  
10663  
10664 < echo "$as_me:$LINENO: checking for ANSI C header files" >&5
10665 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
10666 < if test "${ac_cv_header_stdc+set}" = set; then
10664 >
10665 >
10666 >  if test "${ac_cv_header_iomanip+set}" = set; then
10667 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10668 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10669 > if test "${ac_cv_header_iomanip+set}" = set; then
10670    echo $ECHO_N "(cached) $ECHO_C" >&6
10671 + fi
10672 + echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10673 + echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10674   else
10675 <  cat >conftest.$ac_ext <<_ACEOF
10676 < #line $LINENO "configure"
10675 >  # Is the header compilable?
10676 > echo "$as_me:$LINENO: checking iomanip usability" >&5
10677 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10678 > cat >conftest.$ac_ext <<_ACEOF
10679   /* confdefs.h.  */
10680   _ACEOF
10681   cat confdefs.h >>conftest.$ac_ext
10682   cat >>conftest.$ac_ext <<_ACEOF
10683   /* end confdefs.h.  */
10684 < #include <stdlib.h>
10685 < #include <stdarg.h>
4514 < #include <string.h>
4515 < #include <float.h>
4516 <
4517 < int
4518 < main ()
4519 < {
4520 <
4521 <  ;
4522 <  return 0;
4523 < }
10684 > $ac_includes_default
10685 > #include <iomanip>
10686   _ACEOF
10687   rm -f conftest.$ac_objext
10688   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10689 <  (eval $ac_compile) 2>&5
10689 >  (eval $ac_compile) 2>conftest.er1
10690    ac_status=$?
10691 +  grep -v '^ *+' conftest.er1 >conftest.err
10692 +  rm -f conftest.er1
10693 +  cat conftest.err >&5
10694    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10695    (exit $ac_status); } &&
10696 <         { ac_try='test -s conftest.$ac_objext'
10696 >         { ac_try='test -z "$ac_cxx_werror_flag"
10697 >                         || test ! -s conftest.err'
10698    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10699    (eval $ac_try) 2>&5
10700    ac_status=$?
10701    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10702 +  (exit $ac_status); }; } &&
10703 +         { ac_try='test -s conftest.$ac_objext'
10704 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10705 +  (eval $ac_try) 2>&5
10706 +  ac_status=$?
10707 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10708    (exit $ac_status); }; }; then
10709 <  ac_cv_header_stdc=yes
10709 >  ac_header_compiler=yes
10710   else
10711    echo "$as_me: failed program was:" >&5
10712   sed 's/^/| /' conftest.$ac_ext >&5
10713  
10714 < ac_cv_header_stdc=no
10714 > ac_header_compiler=no
10715   fi
10716 < rm -f conftest.$ac_objext conftest.$ac_ext
10716 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10717 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10718 > echo "${ECHO_T}$ac_header_compiler" >&6
10719  
10720 < if test $ac_cv_header_stdc = yes; then
10721 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
10722 <  cat >conftest.$ac_ext <<_ACEOF
10723 < #line $LINENO "configure"
10720 > # Is the header present?
10721 > echo "$as_me:$LINENO: checking iomanip presence" >&5
10722 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
10723 > cat >conftest.$ac_ext <<_ACEOF
10724   /* confdefs.h.  */
10725   _ACEOF
10726   cat confdefs.h >>conftest.$ac_ext
10727   cat >>conftest.$ac_ext <<_ACEOF
10728   /* end confdefs.h.  */
10729 < #include <string.h>
4556 <
10729 > #include <iomanip>
10730   _ACEOF
10731 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
10732 <  $EGREP "memchr" >/dev/null 2>&1; then
10733 <  :
10731 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10732 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10733 >  ac_status=$?
10734 >  grep -v '^ *+' conftest.er1 >conftest.err
10735 >  rm -f conftest.er1
10736 >  cat conftest.err >&5
10737 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10738 >  (exit $ac_status); } >/dev/null; then
10739 >  if test -s conftest.err; then
10740 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10741 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10742 >  else
10743 >    ac_cpp_err=
10744 >  fi
10745   else
10746 <  ac_cv_header_stdc=no
10746 >  ac_cpp_err=yes
10747   fi
10748 < rm -f conftest*
10748 > if test -z "$ac_cpp_err"; then
10749 >  ac_header_preproc=yes
10750 > else
10751 >  echo "$as_me: failed program was:" >&5
10752 > sed 's/^/| /' conftest.$ac_ext >&5
10753  
10754 +  ac_header_preproc=no
10755   fi
10756 + rm -f conftest.err conftest.$ac_ext
10757 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10758 + echo "${ECHO_T}$ac_header_preproc" >&6
10759  
10760 < if test $ac_cv_header_stdc = yes; then
10761 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
10762 <  cat >conftest.$ac_ext <<_ACEOF
10763 < #line $LINENO "configure"
10760 > # So?  What about this header?
10761 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10762 >  yes:no: )
10763 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
10764 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
10765 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
10766 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
10767 >    ac_header_preproc=yes
10768 >    ;;
10769 >  no:yes:* )
10770 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
10771 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
10772 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
10773 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
10774 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
10775 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
10776 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
10777 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
10778 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
10779 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
10780 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
10781 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
10782 >    (
10783 >      cat <<\_ASBOX
10784 > ## ------------------------------ ##
10785 > ## Report this to gezelter@nd.edu ##
10786 > ## ------------------------------ ##
10787 > _ASBOX
10788 >    ) |
10789 >      sed "s/^/$as_me: WARNING:     /" >&2
10790 >    ;;
10791 > esac
10792 > echo "$as_me:$LINENO: checking for iomanip" >&5
10793 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10794 > if test "${ac_cv_header_iomanip+set}" = set; then
10795 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10796 > else
10797 >  ac_cv_header_iomanip=$ac_header_preproc
10798 > fi
10799 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10800 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10801 >
10802 > fi
10803 > if test $ac_cv_header_iomanip = yes; then
10804 >
10805 >
10806 > cat >>confdefs.h <<\_ACEOF
10807 > #define HAVE_IOMANIP 1
10808 > _ACEOF
10809 >
10810 >
10811 > else
10812 >
10813 >
10814 > for ac_header in iomanip.h
10815 > do
10816 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10817 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10818 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10819 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10820 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10821 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10822 > fi
10823 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10824 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10825 > else
10826 >  # Is the header compilable?
10827 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10828 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10829 > cat >conftest.$ac_ext <<_ACEOF
10830   /* confdefs.h.  */
10831   _ACEOF
10832   cat confdefs.h >>conftest.$ac_ext
10833   cat >>conftest.$ac_ext <<_ACEOF
10834   /* end confdefs.h.  */
10835 < #include <stdlib.h>
10835 > $ac_includes_default
10836 > #include <$ac_header>
10837 > _ACEOF
10838 > rm -f conftest.$ac_objext
10839 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10840 >  (eval $ac_compile) 2>conftest.er1
10841 >  ac_status=$?
10842 >  grep -v '^ *+' conftest.er1 >conftest.err
10843 >  rm -f conftest.er1
10844 >  cat conftest.err >&5
10845 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10846 >  (exit $ac_status); } &&
10847 >         { ac_try='test -z "$ac_cxx_werror_flag"
10848 >                         || test ! -s conftest.err'
10849 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10850 >  (eval $ac_try) 2>&5
10851 >  ac_status=$?
10852 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10853 >  (exit $ac_status); }; } &&
10854 >         { ac_try='test -s conftest.$ac_objext'
10855 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10856 >  (eval $ac_try) 2>&5
10857 >  ac_status=$?
10858 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10859 >  (exit $ac_status); }; }; then
10860 >  ac_header_compiler=yes
10861 > else
10862 >  echo "$as_me: failed program was:" >&5
10863 > sed 's/^/| /' conftest.$ac_ext >&5
10864  
10865 + ac_header_compiler=no
10866 + fi
10867 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10868 + echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10869 + echo "${ECHO_T}$ac_header_compiler" >&6
10870 +
10871 + # Is the header present?
10872 + echo "$as_me:$LINENO: checking $ac_header presence" >&5
10873 + echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10874 + cat >conftest.$ac_ext <<_ACEOF
10875 + /* confdefs.h.  */
10876   _ACEOF
10877 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
10878 <  $EGREP "free" >/dev/null 2>&1; then
10879 <  :
10877 > cat confdefs.h >>conftest.$ac_ext
10878 > cat >>conftest.$ac_ext <<_ACEOF
10879 > /* end confdefs.h.  */
10880 > #include <$ac_header>
10881 > _ACEOF
10882 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10883 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10884 >  ac_status=$?
10885 >  grep -v '^ *+' conftest.er1 >conftest.err
10886 >  rm -f conftest.er1
10887 >  cat conftest.err >&5
10888 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10889 >  (exit $ac_status); } >/dev/null; then
10890 >  if test -s conftest.err; then
10891 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10892 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10893 >  else
10894 >    ac_cpp_err=
10895 >  fi
10896   else
10897 <  ac_cv_header_stdc=no
10897 >  ac_cpp_err=yes
10898   fi
10899 < rm -f conftest*
10899 > if test -z "$ac_cpp_err"; then
10900 >  ac_header_preproc=yes
10901 > else
10902 >  echo "$as_me: failed program was:" >&5
10903 > sed 's/^/| /' conftest.$ac_ext >&5
10904  
10905 +  ac_header_preproc=no
10906   fi
10907 + rm -f conftest.err conftest.$ac_ext
10908 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10909 + echo "${ECHO_T}$ac_header_preproc" >&6
10910  
10911 < if test $ac_cv_header_stdc = yes; then
10912 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
10913 <  if test "$cross_compiling" = yes; then
10914 <  :
10911 > # So?  What about this header?
10912 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10913 >  yes:no: )
10914 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10915 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10916 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10917 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10918 >    ac_header_preproc=yes
10919 >    ;;
10920 >  no:yes:* )
10921 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10922 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10923 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10924 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10925 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10926 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10927 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10928 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10929 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10930 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10931 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10932 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10933 >    (
10934 >      cat <<\_ASBOX
10935 > ## ------------------------------ ##
10936 > ## Report this to gezelter@nd.edu ##
10937 > ## ------------------------------ ##
10938 > _ASBOX
10939 >    ) |
10940 >      sed "s/^/$as_me: WARNING:     /" >&2
10941 >    ;;
10942 > esac
10943 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10944 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10945 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10946 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10947   else
10948 <  cat >conftest.$ac_ext <<_ACEOF
10949 < #line $LINENO "configure"
10948 >  eval "$as_ac_Header=\$ac_header_preproc"
10949 > fi
10950 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10951 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10952 >
10953 > fi
10954 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10955 >  cat >>confdefs.h <<_ACEOF
10956 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10957 > _ACEOF
10958 >
10959 > fi
10960 >
10961 > done
10962 >
10963 >
10964 > fi
10965 >
10966 >
10967 >
10968 >
10969 > for ac_header in cmath
10970 > do
10971 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10972 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10973 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10974 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10975 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10976 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10977 > fi
10978 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10979 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10980 > else
10981 >  # Is the header compilable?
10982 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10983 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10984 > cat >conftest.$ac_ext <<_ACEOF
10985   /* confdefs.h.  */
10986   _ACEOF
10987   cat confdefs.h >>conftest.$ac_ext
10988   cat >>conftest.$ac_ext <<_ACEOF
10989   /* end confdefs.h.  */
10990 < #include <ctype.h>
10991 < #if ((' ' & 0x0FF) == 0x020)
10992 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
10993 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
10994 < #else
10995 < # define ISLOWER(c) \
10996 <                   (('a' <= (c) && (c) <= 'i') \
10997 <                     || ('j' <= (c) && (c) <= 'r') \
10998 <                     || ('s' <= (c) && (c) <= 'z'))
10999 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
10990 > $ac_includes_default
10991 > #include <$ac_header>
10992 > _ACEOF
10993 > rm -f conftest.$ac_objext
10994 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10995 >  (eval $ac_compile) 2>conftest.er1
10996 >  ac_status=$?
10997 >  grep -v '^ *+' conftest.er1 >conftest.err
10998 >  rm -f conftest.er1
10999 >  cat conftest.err >&5
11000 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11001 >  (exit $ac_status); } &&
11002 >         { ac_try='test -z "$ac_cxx_werror_flag"
11003 >                         || test ! -s conftest.err'
11004 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11005 >  (eval $ac_try) 2>&5
11006 >  ac_status=$?
11007 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11008 >  (exit $ac_status); }; } &&
11009 >         { ac_try='test -s conftest.$ac_objext'
11010 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11011 >  (eval $ac_try) 2>&5
11012 >  ac_status=$?
11013 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11014 >  (exit $ac_status); }; }; then
11015 >  ac_header_compiler=yes
11016 > else
11017 >  echo "$as_me: failed program was:" >&5
11018 > sed 's/^/| /' conftest.$ac_ext >&5
11019 >
11020 > ac_header_compiler=no
11021 > fi
11022 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11023 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11024 > echo "${ECHO_T}$ac_header_compiler" >&6
11025 >
11026 > # Is the header present?
11027 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
11028 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11029 > cat >conftest.$ac_ext <<_ACEOF
11030 > /* confdefs.h.  */
11031 > _ACEOF
11032 > cat confdefs.h >>conftest.$ac_ext
11033 > cat >>conftest.$ac_ext <<_ACEOF
11034 > /* end confdefs.h.  */
11035 > #include <$ac_header>
11036 > _ACEOF
11037 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11038 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11039 >  ac_status=$?
11040 >  grep -v '^ *+' conftest.er1 >conftest.err
11041 >  rm -f conftest.er1
11042 >  cat conftest.err >&5
11043 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11044 >  (exit $ac_status); } >/dev/null; then
11045 >  if test -s conftest.err; then
11046 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11047 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11048 >  else
11049 >    ac_cpp_err=
11050 >  fi
11051 > else
11052 >  ac_cpp_err=yes
11053 > fi
11054 > if test -z "$ac_cpp_err"; then
11055 >  ac_header_preproc=yes
11056 > else
11057 >  echo "$as_me: failed program was:" >&5
11058 > sed 's/^/| /' conftest.$ac_ext >&5
11059 >
11060 >  ac_header_preproc=no
11061 > fi
11062 > rm -f conftest.err conftest.$ac_ext
11063 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11064 > echo "${ECHO_T}$ac_header_preproc" >&6
11065 >
11066 > # So?  What about this header?
11067 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11068 >  yes:no: )
11069 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11070 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11071 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11072 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11073 >    ac_header_preproc=yes
11074 >    ;;
11075 >  no:yes:* )
11076 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11077 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11078 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11079 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11080 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11081 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11082 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11083 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11084 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11085 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11086 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11087 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11088 >    (
11089 >      cat <<\_ASBOX
11090 > ## ------------------------------ ##
11091 > ## Report this to gezelter@nd.edu ##
11092 > ## ------------------------------ ##
11093 > _ASBOX
11094 >    ) |
11095 >      sed "s/^/$as_me: WARNING:     /" >&2
11096 >    ;;
11097 > esac
11098 > echo "$as_me:$LINENO: checking for $ac_header" >&5
11099 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11100 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11101 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11102 > else
11103 >  eval "$as_ac_Header=\$ac_header_preproc"
11104 > fi
11105 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11106 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11107 >
11108 > fi
11109 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
11110 >  cat >>confdefs.h <<_ACEOF
11111 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11112 > _ACEOF
11113 >
11114 > fi
11115 >
11116 > done
11117 >
11118 >
11119 >
11120 >
11121 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11122 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11123 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11124 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11125 > else
11126 >
11127 >      ac_cv_cxx_have_std_iostream=no
11128 >      ac_cv_cxx_need_use_std_iostream=no
11129 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11130 >
11131 >
11132 >        ac_ext=cc
11133 > ac_cpp='$CXXCPP $CPPFLAGS'
11134 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11135 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11136 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11137 >
11138 >        cat >conftest.$ac_ext <<_ACEOF
11139 > /* confdefs.h.  */
11140 > _ACEOF
11141 > cat confdefs.h >>conftest.$ac_ext
11142 > cat >>conftest.$ac_ext <<_ACEOF
11143 > /* end confdefs.h.  */
11144 >
11145 > #ifdef HAVE_IOSTREAM
11146 > #include <iostream>
11147 > #else
11148 > #include <iostream.h>
11149   #endif
11150  
11151 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
11151 > #ifdef FC_DUMMY_MAIN
11152 > #ifndef FC_DUMMY_MAIN_EQ_F77
11153 > #  ifdef __cplusplus
11154 >     extern "C"
11155 > #  endif
11156 >   int FC_DUMMY_MAIN() { return 1; }
11157 > #endif
11158 > #endif
11159   int
11160   main ()
11161   {
11162 <  int i;
11163 <  for (i = 0; i < 256; i++)
11164 <    if (XOR (islower (i), ISLOWER (i))
11165 <        || toupper (i) != TOUPPER (i))
11166 <      exit(2);
11167 <  exit (0);
11168 < }
11169 < _ACEOF
11170 < rm -f conftest$ac_exeext
11171 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11172 <  (eval $ac_link) 2>&5
11162 > std::cout<<"Hello World"<<std::endl;return 0;
11163 >  ;
11164 >  return 0;
11165 > }
11166 > _ACEOF
11167 > rm -f conftest.$ac_objext
11168 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11169 >  (eval $ac_compile) 2>conftest.er1
11170 >  ac_status=$?
11171 >  grep -v '^ *+' conftest.er1 >conftest.err
11172 >  rm -f conftest.er1
11173 >  cat conftest.err >&5
11174 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11175 >  (exit $ac_status); } &&
11176 >         { ac_try='test -z "$ac_cxx_werror_flag"
11177 >                         || test ! -s conftest.err'
11178 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11179 >  (eval $ac_try) 2>&5
11180 >  ac_status=$?
11181 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11182 >  (exit $ac_status); }; } &&
11183 >         { ac_try='test -s conftest.$ac_objext'
11184 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11185 >  (eval $ac_try) 2>&5
11186 >  ac_status=$?
11187 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11188 >  (exit $ac_status); }; }; then
11189 >  ac_cv_cxx_have_std_iostream=yes
11190 > else
11191 >  echo "$as_me: failed program was:" >&5
11192 > sed 's/^/| /' conftest.$ac_ext >&5
11193 >
11194 > fi
11195 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11196 >        cat >conftest.$ac_ext <<_ACEOF
11197 > /* confdefs.h.  */
11198 > _ACEOF
11199 > cat confdefs.h >>conftest.$ac_ext
11200 > cat >>conftest.$ac_ext <<_ACEOF
11201 > /* end confdefs.h.  */
11202 >
11203 > #define __USE_STD_IOSTREAM 1
11204 > #ifdef HAVE_IOSTREAM
11205 > #include <iostream>
11206 > #else
11207 > #include <iostream.h>
11208 > #endif
11209 >
11210 > #ifdef FC_DUMMY_MAIN
11211 > #ifndef FC_DUMMY_MAIN_EQ_F77
11212 > #  ifdef __cplusplus
11213 >     extern "C"
11214 > #  endif
11215 >   int FC_DUMMY_MAIN() { return 1; }
11216 > #endif
11217 > #endif
11218 > int
11219 > main ()
11220 > {
11221 > std::cout<<"Hello World"<<std::endl;return 0;
11222 >  ;
11223 >  return 0;
11224 > }
11225 > _ACEOF
11226 > rm -f conftest.$ac_objext
11227 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11228 >  (eval $ac_compile) 2>conftest.er1
11229 >  ac_status=$?
11230 >  grep -v '^ *+' conftest.er1 >conftest.err
11231 >  rm -f conftest.er1
11232 >  cat conftest.err >&5
11233 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11234 >  (exit $ac_status); } &&
11235 >         { ac_try='test -z "$ac_cxx_werror_flag"
11236 >                         || test ! -s conftest.err'
11237 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11238 >  (eval $ac_try) 2>&5
11239    ac_status=$?
11240    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11241 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11241 >  (exit $ac_status); }; } &&
11242 >         { ac_try='test -s conftest.$ac_objext'
11243    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11244    (eval $ac_try) 2>&5
11245    ac_status=$?
11246    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11247    (exit $ac_status); }; }; then
11248 <  :
11248 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11249   else
11250 <  echo "$as_me: program exited with status $ac_status" >&5
4640 < echo "$as_me: failed program was:" >&5
11250 >  echo "$as_me: failed program was:" >&5
11251   sed 's/^/| /' conftest.$ac_ext >&5
11252  
4643 ( exit $ac_status )
4644 ac_cv_header_stdc=no
11253   fi
11254 < rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
11254 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11255 >        ac_ext=cc
11256 > ac_cpp='$CXXCPP $CPPFLAGS'
11257 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11258 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11259 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11260 >
11261 >      fi
11262 >
11263   fi
11264 < fi
11265 < fi
11266 < echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
4651 < echo "${ECHO_T}$ac_cv_header_stdc" >&6
4652 < if test $ac_cv_header_stdc = yes; then
11264 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11265 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11266 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11267  
11268   cat >>confdefs.h <<\_ACEOF
11269 < #define STDC_HEADERS 1
11269 > #define HAVE_STD_IOSTREAM 1
11270   _ACEOF
11271  
11272 < fi
11272 >  fi
11273 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11274  
11275 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
11275 > cat >>confdefs.h <<\_ACEOF
11276 > #define __USE_STD_IOSTREAM 1
11277 > _ACEOF
11278  
11279 +  fi
11280  
11281  
11282  
11283  
11284 +  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11285 + echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11286 + if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11287 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11288 + else
11289  
11290 +      ac_cv_cxx_have_std_stl=no
11291 +      if test "x$ac_cv_cxx_namespaces" = xyes; then
11292  
11293  
11294 +        ac_ext=cc
11295 + ac_cpp='$CXXCPP $CPPFLAGS'
11296 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11297 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11298 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11299  
11300 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
4671 <                  inttypes.h stdint.h unistd.h
4672 < do
4673 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
4674 < echo "$as_me:$LINENO: checking for $ac_header" >&5
4675 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
4676 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
4677 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4678 < else
4679 <  cat >conftest.$ac_ext <<_ACEOF
4680 < #line $LINENO "configure"
11300 >        cat >conftest.$ac_ext <<_ACEOF
11301   /* confdefs.h.  */
11302   _ACEOF
11303   cat confdefs.h >>conftest.$ac_ext
11304   cat >>conftest.$ac_ext <<_ACEOF
11305   /* end confdefs.h.  */
11306 < $ac_includes_default
11306 > #include <list>
11307  
11308 < #include <$ac_header>
11308 > #ifdef FC_DUMMY_MAIN
11309 > #ifndef FC_DUMMY_MAIN_EQ_F77
11310 > #  ifdef __cplusplus
11311 >     extern "C"
11312 > #  endif
11313 >   int FC_DUMMY_MAIN() { return 1; }
11314 > #endif
11315 > #endif
11316 > int
11317 > main ()
11318 > {
11319 > std::list<int> foo;return 0;
11320 >  ;
11321 >  return 0;
11322 > }
11323   _ACEOF
11324   rm -f conftest.$ac_objext
11325   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11326 <  (eval $ac_compile) 2>&5
11326 >  (eval $ac_compile) 2>conftest.er1
11327    ac_status=$?
11328 +  grep -v '^ *+' conftest.er1 >conftest.err
11329 +  rm -f conftest.er1
11330 +  cat conftest.err >&5
11331    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11332    (exit $ac_status); } &&
11333 <         { ac_try='test -s conftest.$ac_objext'
11333 >         { ac_try='test -z "$ac_cxx_werror_flag"
11334 >                         || test ! -s conftest.err'
11335    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11336    (eval $ac_try) 2>&5
11337    ac_status=$?
11338    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11339 +  (exit $ac_status); }; } &&
11340 +         { ac_try='test -s conftest.$ac_objext'
11341 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11342 +  (eval $ac_try) 2>&5
11343 +  ac_status=$?
11344 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11345    (exit $ac_status); }; }; then
11346 <  eval "$as_ac_Header=yes"
11346 >  ac_cv_cxx_have_std_stl=yes
11347   else
11348    echo "$as_me: failed program was:" >&5
11349   sed 's/^/| /' conftest.$ac_ext >&5
11350  
4707 eval "$as_ac_Header=no"
11351   fi
11352 < rm -f conftest.$ac_objext conftest.$ac_ext
11353 < fi
11354 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11355 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11356 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
11357 <  cat >>confdefs.h <<_ACEOF
4715 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
4716 < _ACEOF
11352 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11353 >        ac_ext=cc
11354 > ac_cpp='$CXXCPP $CPPFLAGS'
11355 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11356 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11357 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11358  
11359 +      fi
11360 +
11361   fi
11362 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11363 + echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11364 +  if test "$ac_cv_cxx_have_std_stl" = yes; then
11365  
11366 < done
11366 > cat >>confdefs.h <<\_ACEOF
11367 > #define HAVE_STD_STL 1
11368 > _ACEOF
11369  
11370 +  fi
11371  
11372  
11373  
11374 +  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11375 + echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11376 + if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11377 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11378 + else
11379  
11380 +    ac_cv_cxx_have_fstream_attach=no
11381  
11382  
11383 +    ac_ext=cc
11384 + ac_cpp='$CXXCPP $CPPFLAGS'
11385 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11386 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11387 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11388  
11389 <
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
4733 < do
4734 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
4735 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
4736 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
4737 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
4738 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
4739 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4740 < fi
4741 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
4742 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
4743 < else
4744 <  # Is the header compilable?
4745 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
4746 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
4747 < cat >conftest.$ac_ext <<_ACEOF
4748 < #line $LINENO "configure"
11389 >    cat >conftest.$ac_ext <<_ACEOF
11390   /* confdefs.h.  */
11391   _ACEOF
11392   cat confdefs.h >>conftest.$ac_ext
11393   cat >>conftest.$ac_ext <<_ACEOF
11394   /* end confdefs.h.  */
11395 < $ac_includes_default
11396 < #include <$ac_header>
11395 >
11396 > #ifdef HAVE_IOSTREAM
11397 > #include <fstream>
11398 > #else
11399 > #include <fstream.h>
11400 > #endif
11401 > #ifdef HAVE_STD_IOSTREAM
11402 > using namespace std;
11403 > #endif
11404 >
11405 > #ifdef FC_DUMMY_MAIN
11406 > #ifndef FC_DUMMY_MAIN_EQ_F77
11407 > #  ifdef __cplusplus
11408 >     extern "C"
11409 > #  endif
11410 >   int FC_DUMMY_MAIN() { return 1; }
11411 > #endif
11412 > #endif
11413 > int
11414 > main ()
11415 > {
11416 > int fd=0;ofstream s;s.attach(fd);
11417 >  ;
11418 >  return 0;
11419 > }
11420   _ACEOF
11421   rm -f conftest.$ac_objext
11422   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11423 <  (eval $ac_compile) 2>&5
11423 >  (eval $ac_compile) 2>conftest.er1
11424    ac_status=$?
11425 +  grep -v '^ *+' conftest.er1 >conftest.err
11426 +  rm -f conftest.er1
11427 +  cat conftest.err >&5
11428    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11429    (exit $ac_status); } &&
11430 <         { ac_try='test -s conftest.$ac_objext'
11430 >         { ac_try='test -z "$ac_cxx_werror_flag"
11431 >                         || test ! -s conftest.err'
11432    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11433    (eval $ac_try) 2>&5
11434    ac_status=$?
11435    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11436 +  (exit $ac_status); }; } &&
11437 +         { ac_try='test -s conftest.$ac_objext'
11438 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11439 +  (eval $ac_try) 2>&5
11440 +  ac_status=$?
11441 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11442    (exit $ac_status); }; }; then
11443 <  ac_header_compiler=yes
11443 >  ac_cv_cxx_have_fstream_attach=yes
11444   else
11445    echo "$as_me: failed program was:" >&5
11446   sed 's/^/| /' conftest.$ac_ext >&5
11447  
4774 ac_header_compiler=no
11448   fi
11449 < rm -f conftest.$ac_objext conftest.$ac_ext
11450 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11451 < echo "${ECHO_T}$ac_header_compiler" >&6
11449 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11450 >    ac_ext=cc
11451 > ac_cpp='$CXXCPP $CPPFLAGS'
11452 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11453 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11454 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11455  
4780 # Is the header present?
4781 echo "$as_me:$LINENO: checking $ac_header presence" >&5
4782 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
4783 cat >conftest.$ac_ext <<_ACEOF
4784 #line $LINENO "configure"
4785 /* confdefs.h.  */
4786 _ACEOF
4787 cat confdefs.h >>conftest.$ac_ext
4788 cat >>conftest.$ac_ext <<_ACEOF
4789 /* end confdefs.h.  */
4790 #include <$ac_header>
4791 _ACEOF
4792 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4793  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
4794  ac_status=$?
4795  grep -v '^ *+' conftest.er1 >conftest.err
4796  rm -f conftest.er1
4797  cat conftest.err >&5
4798  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4799  (exit $ac_status); } >/dev/null; then
4800  if test -s conftest.err; then
4801    ac_cpp_err=$ac_c_preproc_warn_flag
4802  else
4803    ac_cpp_err=
4804  fi
4805 else
4806  ac_cpp_err=yes
4807 fi
4808 if test -z "$ac_cpp_err"; then
4809  ac_header_preproc=yes
4810 else
4811  echo "$as_me: failed program was:" >&5
4812 sed 's/^/| /' conftest.$ac_ext >&5
11456  
4814  ac_header_preproc=no
11457   fi
11458 < rm -f conftest.err conftest.$ac_ext
11459 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11460 < echo "${ECHO_T}$ac_header_preproc" >&6
11458 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11459 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11460 >  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11461  
11462 < # So?  What about this header?
11463 < case $ac_header_compiler:$ac_header_preproc in
4822 <  yes:no )
4823 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
4824 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
4825 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
4826 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
4827 <    (
4828 <      cat <<\_ASBOX
4829 < ## ------------------------------------ ##
4830 < ## Report this to bug-autoconf@gnu.org. ##
4831 < ## ------------------------------------ ##
4832 < _ASBOX
4833 <    ) |
4834 <      sed "s/^/$as_me: WARNING:     /" >&2
4835 <    ;;
4836 <  no:yes )
4837 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
4838 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
4839 <    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
4840 < echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
4841 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
4842 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
4843 <    (
4844 <      cat <<\_ASBOX
4845 < ## ------------------------------------ ##
4846 < ## Report this to bug-autoconf@gnu.org. ##
4847 < ## ------------------------------------ ##
4848 < _ASBOX
4849 <    ) |
4850 <      sed "s/^/$as_me: WARNING:     /" >&2
4851 <    ;;
4852 < esac
4853 < echo "$as_me:$LINENO: checking for $ac_header" >&5
4854 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
4855 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
4856 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4857 < else
4858 <  eval "$as_ac_Header=$ac_header_preproc"
4859 < fi
4860 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
4861 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
4862 <
4863 < fi
4864 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
4865 <  cat >>confdefs.h <<_ACEOF
4866 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11462 > cat >>confdefs.h <<\_ACEOF
11463 > #define HAVE_FSTREAM_ATTACH 1
11464   _ACEOF
11465  
11466 < fi
11466 >  fi
11467  
4871 done
11468  
11469  
11470 +  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11471 + echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11472 + if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11473 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11474 + else
11475  
11476 +    ac_cv_cxx_have_fstream_open=no
11477 +    ac_cv_cxx_fstream_open_prot=no
11478  
11479  
11480 +    ac_ext=cc
11481 + ac_cpp='$CXXCPP $CPPFLAGS'
11482 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11483 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11484 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11485  
11486 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
11487 < 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
4884 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4885 < else
4886 <  cat >conftest.$ac_ext <<_ACEOF
4887 < #line $LINENO "configure"
11486 >    # Try with 2 parameters
11487 >    cat >conftest.$ac_ext <<_ACEOF
11488   /* confdefs.h.  */
11489   _ACEOF
11490   cat confdefs.h >>conftest.$ac_ext
11491   cat >>conftest.$ac_ext <<_ACEOF
11492   /* end confdefs.h.  */
11493 < /* System header to define __stub macros and hopefully few prototypes,
11494 <    which can conflict with char $ac_func (); below.
11495 <    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>
11493 >
11494 > #ifdef HAVE_IOSTREAM
11495 > #include <fstream>
11496   #else
11497 < # include <assert.h>
11497 > #include <fstream.h>
11498   #endif
11499 < /* Override any gcc2 internal prototype to avoid an error.  */
11500 < #ifdef __cplusplus
4904 < extern "C"
4905 < {
11499 > #ifdef HAVE_STD_IOSTREAM
11500 > using namespace std;
11501   #endif
11502 < /* We use char because int might match the return type of a gcc2
11503 <   builtin and then its argument prototype would still apply.  */
11504 < char $ac_func ();
11505 < /* The GNU C library defines this for functions which it implements
11506 <    to always fail with ENOSYS.  Some functions are actually named
11507 <    something starting with __ and the normal name is an alias.  */
11508 < #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4914 < choke me
4915 < #else
4916 < char (*f) () = $ac_func;
11502 >
11503 > #ifdef FC_DUMMY_MAIN
11504 > #ifndef FC_DUMMY_MAIN_EQ_F77
11505 > #  ifdef __cplusplus
11506 >     extern "C"
11507 > #  endif
11508 >   int FC_DUMMY_MAIN() { return 1; }
11509   #endif
4918 #ifdef __cplusplus
4919 }
11510   #endif
4921
11511   int
11512   main ()
11513   {
11514 < return f != $ac_func;
11514 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11515    ;
11516    return 0;
11517   }
11518   _ACEOF
11519 < rm -f conftest.$ac_objext conftest$ac_exeext
11520 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11521 <  (eval $ac_link) 2>&5
11519 > rm -f conftest.$ac_objext
11520 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11521 >  (eval $ac_compile) 2>conftest.er1
11522    ac_status=$?
11523 +  grep -v '^ *+' conftest.er1 >conftest.err
11524 +  rm -f conftest.er1
11525 +  cat conftest.err >&5
11526    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11527    (exit $ac_status); } &&
11528 <         { ac_try='test -s conftest$ac_exeext'
11528 >         { ac_try='test -z "$ac_cxx_werror_flag"
11529 >                         || test ! -s conftest.err'
11530    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11531    (eval $ac_try) 2>&5
11532    ac_status=$?
11533    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11534 +  (exit $ac_status); }; } &&
11535 +         { ac_try='test -s conftest.$ac_objext'
11536 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11537 +  (eval $ac_try) 2>&5
11538 +  ac_status=$?
11539 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11540    (exit $ac_status); }; }; then
11541 <  eval "$as_ac_var=yes"
11541 >  ac_cv_cxx_have_fstream_open=yes
11542   else
11543    echo "$as_me: failed program was:" >&5
11544   sed 's/^/| /' conftest.$ac_ext >&5
11545  
4947 eval "$as_ac_var=no"
11546   fi
11547 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
11548 < fi
11549 < 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"
11547 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11548 >    # Try with mode parameter
11549 >    cat >conftest.$ac_ext <<_ACEOF
11550   /* confdefs.h.  */
11551   _ACEOF
11552   cat confdefs.h >>conftest.$ac_ext
11553   cat >>conftest.$ac_ext <<_ACEOF
11554   /* end confdefs.h.  */
11555 < #include <sys/systemcfg.h>
11555 >
11556 > #ifdef HAVE_IOSTREAM
11557 > #include <fstream>
11558 > #else
11559 > #include <fstream.h>
11560 > #endif
11561 > #ifdef HAVE_STD_IOSTREAM
11562 > using namespace std;
11563 > #endif
11564 >
11565 > #ifdef FC_DUMMY_MAIN
11566 > #ifndef FC_DUMMY_MAIN_EQ_F77
11567 > #  ifdef __cplusplus
11568 >     extern "C"
11569 > #  endif
11570 >   int FC_DUMMY_MAIN() { return 1; }
11571 > #endif
11572 > #endif
11573   int
11574   main ()
11575   {
11576 < double x = _system_configuration.physmem;
11576 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11577    ;
11578    return 0;
11579   }
11580   _ACEOF
11581   rm -f conftest.$ac_objext
11582   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11583 <  (eval $ac_compile) 2>&5
11583 >  (eval $ac_compile) 2>conftest.er1
11584    ac_status=$?
11585 +  grep -v '^ *+' conftest.er1 >conftest.err
11586 +  rm -f conftest.er1
11587 +  cat conftest.err >&5
11588    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11589    (exit $ac_status); } &&
11590 <         { ac_try='test -s conftest.$ac_objext'
11590 >         { ac_try='test -z "$ac_cxx_werror_flag"
11591 >                         || test ! -s conftest.err'
11592    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11593    (eval $ac_try) 2>&5
11594    ac_status=$?
11595    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11596 +  (exit $ac_status); }; } &&
11597 +         { ac_try='test -s conftest.$ac_objext'
11598 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11599 +  (eval $ac_try) 2>&5
11600 +  ac_status=$?
11601 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11602    (exit $ac_status); }; }; then
11603 <  echo "$as_me:$LINENO: result: yes" >&5
4994 < echo "${ECHO_T}yes" >&6
4995 <
4996 < cat >>confdefs.h <<\_ACEOF
4997 < #define HAVE__SYSTEM_CONFIGURATION 1
4998 < _ACEOF
4999 <
11603 >  ac_cv_cxx_fstream_open_prot=yes
11604   else
11605    echo "$as_me: failed program was:" >&5
11606   sed 's/^/| /' conftest.$ac_ext >&5
11607  
5004 echo "$as_me:$LINENO: result: no" >&5
5005 echo "${ECHO_T}no" >&6
11608   fi
11609 < rm -f conftest.$ac_objext conftest.$ac_ext
11609 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11610 >    ac_ext=cc
11611 > ac_cpp='$CXXCPP $CPPFLAGS'
11612 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11613 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11614 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11615  
5009  # clean out junk possibly left behind by a previous configuration
5010  rm -f src/getopt.h
5011  # Check for getopt_long support
11616  
11617 < for ac_header in getopt.h
11617 > fi
11618 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11619 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11620 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11621 >
11622 > cat >>confdefs.h <<\_ACEOF
11623 > #define HAVE_FSTREAM_OPEN 1
11624 > _ACEOF
11625 >
11626 >  fi
11627 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11628 >
11629 > cat >>confdefs.h <<\_ACEOF
11630 > #define FSTREAM_OPEN_PROT 1
11631 > _ACEOF
11632 >
11633 >  fi
11634 >
11635 >
11636 >
11637 >
11638 >
11639 >
11640 >
11641 > for ac_header in ctype.h iostream fstream sstream strstream
11642   do
11643   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11644   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 5026 | Line 11654 | cat >conftest.$ac_ext <<_ACEOF
11654   echo "$as_me:$LINENO: checking $ac_header usability" >&5
11655   echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11656   cat >conftest.$ac_ext <<_ACEOF
5029 #line $LINENO "configure"
11657   /* confdefs.h.  */
11658   _ACEOF
11659   cat confdefs.h >>conftest.$ac_ext
# Line 5037 | Line 11664 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11664   _ACEOF
11665   rm -f conftest.$ac_objext
11666   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11667 <  (eval $ac_compile) 2>&5
11667 >  (eval $ac_compile) 2>conftest.er1
11668    ac_status=$?
11669 +  grep -v '^ *+' conftest.er1 >conftest.err
11670 +  rm -f conftest.er1
11671 +  cat conftest.err >&5
11672    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11673    (exit $ac_status); } &&
11674 <         { ac_try='test -s conftest.$ac_objext'
11674 >         { ac_try='test -z "$ac_cxx_werror_flag"
11675 >                         || test ! -s conftest.err'
11676    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11677    (eval $ac_try) 2>&5
11678    ac_status=$?
11679    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11680 +  (exit $ac_status); }; } &&
11681 +         { ac_try='test -s conftest.$ac_objext'
11682 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11683 +  (eval $ac_try) 2>&5
11684 +  ac_status=$?
11685 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11686    (exit $ac_status); }; }; then
11687    ac_header_compiler=yes
11688   else
# Line 5054 | Line 11691 | fi
11691  
11692   ac_header_compiler=no
11693   fi
11694 < rm -f conftest.$ac_objext conftest.$ac_ext
11694 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11695   echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11696   echo "${ECHO_T}$ac_header_compiler" >&6
11697  
# Line 5062 | Line 11699 | cat >conftest.$ac_ext <<_ACEOF
11699   echo "$as_me:$LINENO: checking $ac_header presence" >&5
11700   echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11701   cat >conftest.$ac_ext <<_ACEOF
5065 #line $LINENO "configure"
11702   /* confdefs.h.  */
11703   _ACEOF
11704   cat confdefs.h >>conftest.$ac_ext
# Line 5079 | Line 11715 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11715    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11716    (exit $ac_status); } >/dev/null; then
11717    if test -s conftest.err; then
11718 <    ac_cpp_err=$ac_c_preproc_warn_flag
11718 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11719 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11720    else
11721      ac_cpp_err=
11722    fi
# Line 5099 | Line 11736 | echo "${ECHO_T}$ac_header_preproc" >&6
11736   echo "${ECHO_T}$ac_header_preproc" >&6
11737  
11738   # So?  What about this header?
11739 < case $ac_header_compiler:$ac_header_preproc in
11740 <  yes:no )
11739 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11740 >  yes:no: )
11741      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11742   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11743 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11744 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11745 <    (
5109 <      cat <<\_ASBOX
5110 < ## ------------------------------------ ##
5111 < ## Report this to bug-autoconf@gnu.org. ##
5112 < ## ------------------------------------ ##
5113 < _ASBOX
5114 <    ) |
5115 <      sed "s/^/$as_me: WARNING:     /" >&2
11743 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11744 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11745 >    ac_header_preproc=yes
11746      ;;
11747 <  no:yes )
11747 >  no:yes:* )
11748      { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11749   echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11750 <    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
11751 < echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
11750 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11751 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11752 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11753 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11754 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11755 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11756      { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11757   echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11758 +    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11759 + echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11760      (
11761        cat <<\_ASBOX
11762 < ## ------------------------------------ ##
11763 < ## Report this to bug-autoconf@gnu.org. ##
11764 < ## ------------------------------------ ##
11762 > ## ------------------------------ ##
11763 > ## Report this to gezelter@nd.edu ##
11764 > ## ------------------------------ ##
11765   _ASBOX
11766      ) |
11767        sed "s/^/$as_me: WARNING:     /" >&2
# Line 5136 | Line 11772 | else
11772   if eval "test \"\${$as_ac_Header+set}\" = set"; then
11773    echo $ECHO_N "(cached) $ECHO_C" >&6
11774   else
11775 <  eval "$as_ac_Header=$ac_header_preproc"
11775 >  eval "$as_ac_Header=\$ac_header_preproc"
11776   fi
11777   echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11778   echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
# Line 5151 | Line 11787 | done
11787  
11788   done
11789  
11790 + # AC_CPP_FUNC
11791 + # ------------------ #
11792 + # Checks to see if ANSI C99 CPP variable __func__ works.
11793 + # If not, perhaps __FUNCTION__ works instead.
11794 + # If not, we'll just define __func__ to "".
11795 + # AC_CPP_FUNC
11796  
11797 < for ac_func in getopt_long
11798 < do
11799 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11800 < 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
11797 >
11798 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11799 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11800 > if test "${ac_cv_cpp_func+set}" = set; then
11801    echo $ECHO_N "(cached) $ECHO_C" >&6
11802   else
11803    cat >conftest.$ac_ext <<_ACEOF
5164 #line $LINENO "configure"
11804   /* confdefs.h.  */
11805   _ACEOF
11806   cat confdefs.h >>conftest.$ac_ext
11807   cat >>conftest.$ac_ext <<_ACEOF
11808   /* end confdefs.h.  */
11809 < /* System header to define __stub macros and hopefully few prototypes,
11810 <    which can conflict with char $ac_func (); below.
11811 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11812 <    <limits.h> exists even on freestanding compilers.  */
11813 < #ifdef __STDC__
11814 < # include <limits.h>
11815 < #else
5177 < # include <assert.h>
11809 >
11810 > #ifdef FC_DUMMY_MAIN
11811 > #ifndef FC_DUMMY_MAIN_EQ_F77
11812 > #  ifdef __cplusplus
11813 >     extern "C"
11814 > #  endif
11815 >   int FC_DUMMY_MAIN() { return 1; }
11816   #endif
5179 /* Override any gcc2 internal prototype to avoid an error.  */
5180 #ifdef __cplusplus
5181 extern "C"
5182 {
11817   #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
11818   int
11819   main ()
11820   {
11821 < return f != $ac_func;
11821 > const char *foo = __func__;
11822    ;
11823    return 0;
11824   }
11825   _ACEOF
11826 < rm -f conftest.$ac_objext conftest$ac_exeext
11827 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11828 <  (eval $ac_link) 2>&5
11826 > rm -f conftest.$ac_objext
11827 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11828 >  (eval $ac_compile) 2>conftest.er1
11829    ac_status=$?
11830 +  grep -v '^ *+' conftest.er1 >conftest.err
11831 +  rm -f conftest.er1
11832 +  cat conftest.err >&5
11833    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11834    (exit $ac_status); } &&
11835 <         { ac_try='test -s conftest$ac_exeext'
11835 >         { ac_try='test -z "$ac_cxx_werror_flag"
11836 >                         || test ! -s conftest.err'
11837    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11838    (eval $ac_try) 2>&5
11839    ac_status=$?
11840    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11841 +  (exit $ac_status); }; } &&
11842 +         { ac_try='test -s conftest.$ac_objext'
11843 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11844 +  (eval $ac_try) 2>&5
11845 +  ac_status=$?
11846 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11847    (exit $ac_status); }; }; then
11848 <  eval "$as_ac_var=yes"
11848 >  ac_cv_cpp_func=yes
11849   else
11850    echo "$as_me: failed program was:" >&5
11851   sed 's/^/| /' conftest.$ac_ext >&5
11852  
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"
11853   cat >conftest.$ac_ext <<_ACEOF
5245 #line $LINENO "configure"
11854   /* confdefs.h.  */
11855   _ACEOF
11856   cat confdefs.h >>conftest.$ac_ext
11857   cat >>conftest.$ac_ext <<_ACEOF
11858   /* end confdefs.h.  */
11859  
11860 < /* Override any gcc2 internal prototype to avoid an error.  */
11861 < #ifdef __cplusplus
11862 < extern "C"
11860 > #ifdef FC_DUMMY_MAIN
11861 > #ifndef FC_DUMMY_MAIN_EQ_F77
11862 > #  ifdef __cplusplus
11863 >     extern "C"
11864 > #  endif
11865 >   int FC_DUMMY_MAIN() { return 1; }
11866   #endif
11867 < /* 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 ();
11867 > #endif
11868   int
11869   main ()
11870   {
11871 < getopt_long ();
11871 > const char *foo = __FUNCTION__;
11872    ;
11873    return 0;
11874   }
11875   _ACEOF
11876 < rm -f conftest.$ac_objext conftest$ac_exeext
11877 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11878 <  (eval $ac_link) 2>&5
11876 > rm -f conftest.$ac_objext
11877 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11878 >  (eval $ac_compile) 2>conftest.er1
11879    ac_status=$?
11880 +  grep -v '^ *+' conftest.er1 >conftest.err
11881 +  rm -f conftest.er1
11882 +  cat conftest.err >&5
11883    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11884    (exit $ac_status); } &&
11885 <         { ac_try='test -s conftest$ac_exeext'
11885 >         { ac_try='test -z "$ac_cxx_werror_flag"
11886 >                         || test ! -s conftest.err'
11887    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11888    (eval $ac_try) 2>&5
11889    ac_status=$?
11890    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11891 +  (exit $ac_status); }; } &&
11892 +         { ac_try='test -s conftest.$ac_objext'
11893 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11894 +  (eval $ac_try) 2>&5
11895 +  ac_status=$?
11896 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11897    (exit $ac_status); }; }; then
11898 <  ac_cv_lib_gnugetopt_getopt_long=yes
11898 >  ac_cv_cpp_func=__FUNCTION__
11899   else
11900    echo "$as_me: failed program was:" >&5
11901   sed 's/^/| /' conftest.$ac_ext >&5
11902  
11903 < ac_cv_lib_gnugetopt_getopt_long=no
11903 > ac_cv_cpp_func=no
11904   fi
11905 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
5287 < LIBS=$ac_check_lib_save_LIBS
11905 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11906   fi
11907 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
11908 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
11909 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
11910 <  cat >>confdefs.h <<\_ACEOF
11911 < #define HAVE_GETOPT_LONG 1
11907 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11908 > fi
11909 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11910 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
11911 > if test $ac_cv_cpp_func = __FUNCTION__; then
11912 >
11913 > cat >>confdefs.h <<\_ACEOF
11914 > #define __func__ __FUNCTION__
11915   _ACEOF
11916  
11917 < 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"
11917 > elif test $ac_cv_cpp_func = no; then
11918  
11919 < fi
11919 > cat >>confdefs.h <<\_ACEOF
11920 > #define __func__ ""
11921 > _ACEOF
11922  
11923   fi
5305 done
11924  
11925  
11926  
11927 +
11928 +
11929   case $debug in
11930    1)
11931       ;;
11932    *)
11933 +
11934 +
11935 +
11936 +
11937 + # Try to determine "good" native compiler flags if none specified on command
11938 + # line
11939 +
11940 + if test "$ac_test_FFLAGS" != "set"; then
11941 +  FCFLAGS=""
11942 +  case "${host_cpu}-${host_os}" in
11943 +
11944 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11945 +                    FCFLAGS="-O3 -ip -no-prec-div -cxxlib-icc"
11946 +                fi;;
11947 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11948 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11949 +                fi;;
11950 +   powerpc*-aix*)
11951 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11952 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11953 +                echo "*******************************************************"
11954 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
11955 +                echo "*  recommended that you use                           *"
11956 +                echo "*                                                     *"
11957 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
11958 +                echo "*                                 ^^^                 *"
11959 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
11960 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
11961 +                echo "*******************************************************"
11962 +        fi;;
11963 +   *darwin*)
11964 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11965 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
11966 +        fi
11967 +        if test "$FC" = ifort; then
11968 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
11969 +        fi;;
11970 +  esac
11971  
11972 +  if test -n "$CPU_FLAGS"; then
11973 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
11974 +  fi
11975  
11976 +  if test -z "$FCFLAGS"; then
11977 +        echo ""
11978 +        echo "*********************************************************"
11979 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
11980 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11981 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
11982 +        echo "*********************************************************"
11983 +        echo ""
11984 +        FCFLAGS="-O3"
11985 +  fi
11986  
11987  
11988 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
11989 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
11990 + if test "${ac_guessed_f90flags+set}" = set; then
11991 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11992 + else
11993  
11994  
11995 +
11996 + ac_ext=${FC_SRCEXT-f}
11997 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
11998 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
11999 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12000 +
12001 + echo 'program main' > conftest.$ac_ext
12002 + echo 'end program main' >> conftest.$ac_ext
12003 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12004 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12005 +  (eval $ac_compile) 2>&5
12006 +  ac_status=$?
12007 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12008 +  (exit $ac_status); }; then
12009 +        ac_guessed_f90flags=yes
12010 + else
12011 +        ac_guessed_f90flags=no
12012 + fi
12013 + rm -f conftest*
12014 + ac_ext=cc
12015 + ac_cpp='$CXXCPP $CPPFLAGS'
12016 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12017 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12018 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12019 +
12020 +
12021 + fi
12022 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12023 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
12024 + if test "$ac_guessed_f90flags" = yes; then
12025 +        :
12026 +
12027 + else
12028 +        :
12029 +
12030 +        echo ""
12031 +        echo "**********************************************************"
12032 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12033 +        echo "* your compiler.                                        *"
12034 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12035 +        echo "*********************************************************"
12036 +        echo ""
12037 +        FCFLAGS=""
12038 +
12039 + fi
12040 +
12041 +
12042 + fi
12043 +
12044 +
12045 +
12046 +
12047 +
12048 +
12049 +
12050   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12051   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12052   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 5324 | Line 12055 | cat > conftest.c <<EOF
12055  
12056   cat > conftest.c <<EOF
12057   #ifdef __GNUC__
12058 <  #ifndef __INTEL_COMPILER
12058 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12059 >     no;
12060 >  #else
12061       yes;
12062    #endif
12063   #endif
# Line 5362 | Line 12095 | if test "$ac_test_CFLAGS" != "set"; then
12095                      CFLAGS="-O"
12096                  fi;;
12097    sparc-solaris2*) if test "$CC" = cc; then
12098 <                    CFLAGS="-native -fast -xO5 -dalign"
12098 >                    CFLAGS="-O -dalign"
12099                   fi;;
12100  
12101    alpha*-osf*)  if test "$CC" = cc; then
# Line 5392 | Line 12125 | if test "$ac_test_CFLAGS" != "set"; then
12125     *darwin*)
12126          if test "$CC" = xlc -o "$CC" = cc; then
12127                  CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12128 +        fi
12129 +        if test "$CC" = icc; then
12130 +                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12131          fi;;
12132    esac
12133  
# Line 5405 | Line 12141 | if test "$ac_test_CFLAGS" != "set"; then
12141      # -malign-double for x86 systems
12142  
12143  
12144 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12145 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12144 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12145 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12146   if test "${ac_align_double+set}" = set; then
12147    echo $ECHO_N "(cached) $ECHO_C" >&6
12148   else
12149    echo 'void f(){}' > conftest.c
12150 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12150 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12151          ac_align_double=yes
12152   else
12153          ac_align_double=no
# Line 5432 | Line 12168 | fi
12168      # -fstrict-aliasing for gcc-2.95+
12169  
12170  
12171 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12172 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12171 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12172 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12173   if test "${ac_fstrict_aliasing+set}" = set; then
12174    echo $ECHO_N "(cached) $ECHO_C" >&6
12175   else
12176    echo 'void f(){}' > conftest.c
12177 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12177 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12178          ac_fstrict_aliasing=yes
12179   else
12180          ac_fstrict_aliasing=no
# Line 5463 | Line 12199 | fi
12199                    case "${host_cpu}" in
12200            i586*)
12201  
12202 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12203 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12202 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12203 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12204   if test "${ac_cpu_pentium+set}" = set; then
12205    echo $ECHO_N "(cached) $ECHO_C" >&6
12206   else
12207    echo 'void f(){}' > conftest.c
12208 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12208 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12209          ac_cpu_pentium=yes
12210   else
12211          ac_cpu_pentium=no
# Line 5486 | Line 12222 | else
12222          :
12223  
12224  
12225 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12226 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12225 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12226 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12227   if test "${ac_pentium+set}" = set; then
12228    echo $ECHO_N "(cached) $ECHO_C" >&6
12229   else
12230    echo 'void f(){}' > conftest.c
12231 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12231 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12232          ac_pentium=yes
12233   else
12234          ac_pentium=no
# Line 5515 | Line 12251 | fi
12251                    ;;
12252            i686*)
12253  
12254 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12255 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12254 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12255 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12256   if test "${ac_cpu_pentiumpro+set}" = set; then
12257    echo $ECHO_N "(cached) $ECHO_C" >&6
12258   else
12259    echo 'void f(){}' > conftest.c
12260 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12260 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12261          ac_cpu_pentiumpro=yes
12262   else
12263          ac_cpu_pentiumpro=no
# Line 5538 | Line 12274 | else
12274          :
12275  
12276  
12277 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12278 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12277 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12278 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12279   if test "${ac_pentiumpro+set}" = set; then
12280    echo $ECHO_N "(cached) $ECHO_C" >&6
12281   else
12282    echo 'void f(){}' > conftest.c
12283 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12283 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12284          ac_pentiumpro=yes
12285   else
12286          ac_pentiumpro=no
# Line 5571 | Line 12307 | fi
12307                  if test -n "$is60x"; then
12308  
12309  
12310 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12311 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12310 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12311 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12312   if test "${ac_m_cpu_60x+set}" = set; then
12313    echo $ECHO_N "(cached) $ECHO_C" >&6
12314   else
12315    echo 'void f(){}' > conftest.c
12316 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12316 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12317          ac_m_cpu_60x=yes
12318   else
12319          ac_m_cpu_60x=no
# Line 5629 | Line 12365 | if test "$ac_cv_prog_gcc_2_95" = yes; then
12365          :
12366  
12367  
12368 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12369 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12368 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12369 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12370   if test "${ac_m_cpu_750+set}" = set; then
12371    echo $ECHO_N "(cached) $ECHO_C" >&6
12372   else
12373    echo 'void f(){}' > conftest.c
12374 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12374 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12375          ac_m_cpu_750=yes
12376   else
12377          ac_m_cpu_750=no
# Line 5662 | Line 12398 | fi
12398                  if test -z "$CPU_FLAGS"; then
12399  
12400  
12401 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12402 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12401 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12402 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12403   if test "${ac_m_cpu_powerpc+set}" = set; then
12404    echo $ECHO_N "(cached) $ECHO_C" >&6
12405   else
12406    echo 'void f(){}' > conftest.c
12407 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12407 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12408          ac_m_cpu_powerpc=yes
12409   else
12410          ac_m_cpu_powerpc=no
# Line 5690 | Line 12426 | fi
12426                  if test -z "$CPU_FLAGS"; then
12427  
12428  
12429 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12430 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12429 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12430 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12431   if test "${ac_m_powerpc+set}" = set; then
12432    echo $ECHO_N "(cached) $ECHO_C" >&6
12433   else
12434    echo 'void f(){}' > conftest.c
12435 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12435 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12436          ac_m_powerpc=yes
12437   else
12438          ac_m_powerpc=no
# Line 5735 | Line 12471 | fi
12471  
12472  
12473  
12474 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12475 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12474 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12475 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12476   if test "${ac_guessed_cflags+set}" = set; then
12477    echo $ECHO_N "(cached) $ECHO_C" >&6
12478   else
12479    echo 'void f(){}' > conftest.c
12480 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12480 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12481          ac_guessed_cflags=yes
12482   else
12483          ac_guessed_cflags=no
# Line 5785 | Line 12521 | cat > conftest.cpp <<EOF
12521  
12522   cat > conftest.cpp <<EOF
12523   #ifdef __GNUC__
12524 <  #ifndef __INTEL_COMPILER
12524 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12525 >     no;
12526 >  #else
12527       yes;
12528    #endif
12529   #endif
# Line 5823 | Line 12561 | if test "$ac_test_CXXFLAGS" != "set"; then
12561                      CXXFLAGS="-O"
12562                  fi;;
12563    sparc-solaris2*) if test "$CXX" = CC; then
12564 <                    CXXFLAGS="-native -fast -xO5 -dalign"
12564 >                    CXXFLAGS="-features=extensions -O -dalign"
12565                   fi;;
12566     rs6000*-aix*)  if test "$CXX" = xlC; then
12567                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 5844 | Line 12582 | if test "$ac_test_CXXFLAGS" != "set"; then
12582     *darwin*)
12583          if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12584                  CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12585 +        fi
12586 +        if test "$CXX" = icpc; then
12587 +                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12588          fi;;
12589    esac
12590  
# Line 5857 | Line 12598 | if test "$ac_test_CXXFLAGS" != "set"; then
12598      # -malign-double for x86 systems
12599  
12600  
12601 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12602 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12601 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12602 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12603   if test "${ac_align_double+set}" = set; then
12604    echo $ECHO_N "(cached) $ECHO_C" >&6
12605   else
12606    echo 'void f(){}' > conftest.cpp
12607 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12607 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12608          ac_align_double=yes
12609   else
12610          ac_align_double=no
# Line 5884 | Line 12625 | fi
12625      # -fstrict-aliasing for gcc-2.95+
12626  
12627  
12628 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12629 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12628 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12629 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12630   if test "${ac_fstrict_aliasing+set}" = set; then
12631    echo $ECHO_N "(cached) $ECHO_C" >&6
12632   else
12633    echo 'void f(){}' > conftest.cpp
12634 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12634 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12635          ac_fstrict_aliasing=yes
12636   else
12637          ac_fstrict_aliasing=no
# Line 5915 | Line 12656 | fi
12656                    case "${host_cpu}" in
12657            i586*)
12658  
12659 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12660 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12659 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12660 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12661   if test "${ac_cpu_pentium+set}" = set; then
12662    echo $ECHO_N "(cached) $ECHO_C" >&6
12663   else
12664    echo 'void f(){}' > conftest.cpp
12665 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12665 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12666          ac_cpu_pentium=yes
12667   else
12668          ac_cpu_pentium=no
# Line 5938 | Line 12679 | else
12679          :
12680  
12681  
12682 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12683 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12682 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12683 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12684   if test "${ac_pentium+set}" = set; then
12685    echo $ECHO_N "(cached) $ECHO_C" >&6
12686   else
12687    echo 'void f(){}' > conftest.cpp
12688 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12688 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12689          ac_pentium=yes
12690   else
12691          ac_pentium=no
# Line 5967 | Line 12708 | fi
12708                    ;;
12709            i686*)
12710  
12711 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
12712 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12711 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
12712 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12713   if test "${ac_cpu_pentiumpro+set}" = set; then
12714    echo $ECHO_N "(cached) $ECHO_C" >&6
12715   else
12716    echo 'void f(){}' > conftest.cpp
12717 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12717 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12718          ac_cpu_pentiumpro=yes
12719   else
12720          ac_cpu_pentiumpro=no
# Line 5990 | Line 12731 | else
12731          :
12732  
12733  
12734 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
12735 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
12734 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
12735 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
12736   if test "${ac_pentiumpro+set}" = set; then
12737    echo $ECHO_N "(cached) $ECHO_C" >&6
12738   else
12739    echo 'void f(){}' > conftest.cpp
12740 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
12740 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12741          ac_pentiumpro=yes
12742   else
12743          ac_pentiumpro=no
# Line 6023 | Line 12764 | fi
12764                  if test -n "$is60x"; then
12765  
12766  
12767 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
12768 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
12767 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
12768 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
12769   if test "${ac_m_cpu_60x+set}" = set; then
12770    echo $ECHO_N "(cached) $ECHO_C" >&6
12771   else
12772    echo 'void f(){}' > conftest.cpp
12773 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12773 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12774          ac_m_cpu_60x=yes
12775   else
12776          ac_m_cpu_60x=no
# Line 6081 | Line 12822 | if test "$ac_cv_prog_gxx_2_95" = yes; then
12822          :
12823  
12824  
12825 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
12826 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
12825 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12826 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12827   if test "${ac_m_cpu_750+set}" = set; then
12828    echo $ECHO_N "(cached) $ECHO_C" >&6
12829   else
12830    echo 'void f(){}' > conftest.cpp
12831 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
12831 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12832          ac_m_cpu_750=yes
12833   else
12834          ac_m_cpu_750=no
# Line 6114 | Line 12855 | fi
12855                  if test -z "$CPU_FLAGS"; then
12856  
12857  
12858 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
12859 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
12858 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12859 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12860   if test "${ac_m_cpu_powerpc+set}" = set; then
12861    echo $ECHO_N "(cached) $ECHO_C" >&6
12862   else
12863    echo 'void f(){}' > conftest.cpp
12864 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12864 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12865          ac_m_cpu_powerpc=yes
12866   else
12867          ac_m_cpu_powerpc=no
# Line 6142 | Line 12883 | fi
12883                  if test -z "$CPU_FLAGS"; then
12884  
12885  
12886 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
12887 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
12886 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12887 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12888   if test "${ac_m_powerpc+set}" = set; then
12889    echo $ECHO_N "(cached) $ECHO_C" >&6
12890   else
12891    echo 'void f(){}' > conftest.cpp
12892 < if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
12892 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12893          ac_m_powerpc=yes
12894   else
12895          ac_m_powerpc=no
# Line 6187 | Line 12928 | fi
12928  
12929  
12930  
12931 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
12932 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
12931 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12932 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12933   if test "${ac_guessed_cxxflags+set}" = set; then
12934    echo $ECHO_N "(cached) $ECHO_C" >&6
12935   else
12936    echo 'void f(){}' > conftest.cpp
12937 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12937 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12938          ac_guessed_cxxflags=yes
12939   else
12940          ac_guessed_cxxflags=no
# Line 6223 | Line 12964 | fi
12964  
12965   fi
12966  
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
6236
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
6302 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
6309
6310
6311 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        :
6316
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
12967       ;;
12968   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    ;;
6388 esac
6389 done
6390
6391
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
12969  
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
12970  
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
12971   cat >>confdefs.h <<\_ACEOF
12972 < #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
6988 < _ACEOF
6989 <
6990 <
6991 < cat >>confdefs.h <<_ACEOF
6992 < #define PSTYPE $ac_cv_prog_ps_syntax
12972 > #define OBAPI
12973   _ACEOF
12974  
12975  
# Line 7023 | Line 13003 | have_mpi_h=0
13003   echo "$as_me:$LINENO: checking for mpi.h" >&5
13004   echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
13005   have_mpi_h=0
13006 + rm -f conftest*
13007   echo '#include <mpi.h>' > conftest.cc
13008 < if test -z "`${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1`"; then
13008 > if ${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1 ; then
13009          echo "$as_me:$LINENO: result: yes" >&5
13010   echo "${ECHO_T}yes" >&6
13011          have_mpi_h=1
13012   else
13013 +        if test -s conftest.out ; then
13014 +                cat conftest.out >> config.log
13015 +        fi
13016          echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
13017   echo "${ECHO_T}no! Check MPI include paths" >&6
13018          USE_MPI="no"
# Line 7046 | Line 13030 | rm -f conftest*
13030   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13031   have_mpif_h=0
13032   rm -f conftest*
13033 < cat >conftest.f90 <<EOF
13033 > cat >conftest.$ac_ext <<EOF
13034   program main
13035     include 'mpif.h'
13036   end
13037   EOF
13038 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13038 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13039          echo "$as_me:$LINENO: result: yes" >&5
13040   echo "${ECHO_T}yes" >&6
13041          MPI_F90_INC="$MPI_INC_DIR"
# Line 7092 | Line 13076 | cat >conftest.$ac_ext <<_ACEOF
13076    ac_check_lib_save_LIBS=$LIBS
13077   LIBS="-lmpich  $LIBS"
13078   cat >conftest.$ac_ext <<_ACEOF
7095 #line $LINENO "configure"
13079   /* confdefs.h.  */
13080   _ACEOF
13081   cat confdefs.h >>conftest.$ac_ext
# Line 7106 | Line 13089 | char MPI_Init ();
13089   /* We use char because int might match the return type of a gcc2
13090     builtin and then its argument prototype would still apply.  */
13091   char MPI_Init ();
13092 + #ifdef FC_DUMMY_MAIN
13093 + #ifndef FC_DUMMY_MAIN_EQ_F77
13094 + #  ifdef __cplusplus
13095 +     extern "C"
13096 + #  endif
13097 +   int FC_DUMMY_MAIN() { return 1; }
13098 + #endif
13099 + #endif
13100   int
13101   main ()
13102   {
# Line 7116 | Line 13107 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13107   _ACEOF
13108   rm -f conftest.$ac_objext conftest$ac_exeext
13109   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13110 <  (eval $ac_link) 2>&5
13110 >  (eval $ac_link) 2>conftest.er1
13111    ac_status=$?
13112 +  grep -v '^ *+' conftest.er1 >conftest.err
13113 +  rm -f conftest.er1
13114 +  cat conftest.err >&5
13115    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13116    (exit $ac_status); } &&
13117 <         { ac_try='test -s conftest$ac_exeext'
13117 >         { ac_try='test -z "$ac_c_werror_flag"
13118 >                         || test ! -s conftest.err'
13119    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13120    (eval $ac_try) 2>&5
13121    ac_status=$?
13122    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13123 +  (exit $ac_status); }; } &&
13124 +         { ac_try='test -s conftest$ac_exeext'
13125 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13126 +  (eval $ac_try) 2>&5
13127 +  ac_status=$?
13128 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13129    (exit $ac_status); }; }; then
13130    ac_cv_lib_mpich_MPI_Init=yes
13131   else
# Line 7133 | Line 13134 | fi
13134  
13135   ac_cv_lib_mpich_MPI_Init=no
13136   fi
13137 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
13137 > rm -f conftest.err conftest.$ac_objext \
13138 >      conftest$ac_exeext conftest.$ac_ext
13139   LIBS=$ac_check_lib_save_LIBS
13140   fi
13141   echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
# Line 7152 | Line 13154 | cat >conftest.$ac_ext <<_ACEOF
13154    ac_check_lib_save_LIBS=$LIBS
13155   LIBS="-lmpi  $LIBS"
13156   cat >conftest.$ac_ext <<_ACEOF
7155 #line $LINENO "configure"
13157   /* confdefs.h.  */
13158   _ACEOF
13159   cat confdefs.h >>conftest.$ac_ext
# Line 7166 | Line 13167 | char MPI_Init ();
13167   /* We use char because int might match the return type of a gcc2
13168     builtin and then its argument prototype would still apply.  */
13169   char MPI_Init ();
13170 + #ifdef FC_DUMMY_MAIN
13171 + #ifndef FC_DUMMY_MAIN_EQ_F77
13172 + #  ifdef __cplusplus
13173 +     extern "C"
13174 + #  endif
13175 +   int FC_DUMMY_MAIN() { return 1; }
13176 + #endif
13177 + #endif
13178   int
13179   main ()
13180   {
# Line 7176 | Line 13185 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13185   _ACEOF
13186   rm -f conftest.$ac_objext conftest$ac_exeext
13187   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13188 <  (eval $ac_link) 2>&5
13188 >  (eval $ac_link) 2>conftest.er1
13189    ac_status=$?
13190 +  grep -v '^ *+' conftest.er1 >conftest.err
13191 +  rm -f conftest.er1
13192 +  cat conftest.err >&5
13193    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13194    (exit $ac_status); } &&
13195 <         { ac_try='test -s conftest$ac_exeext'
13195 >         { ac_try='test -z "$ac_c_werror_flag"
13196 >                         || test ! -s conftest.err'
13197    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13198    (eval $ac_try) 2>&5
13199    ac_status=$?
13200    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13201 +  (exit $ac_status); }; } &&
13202 +         { ac_try='test -s conftest$ac_exeext'
13203 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13204 +  (eval $ac_try) 2>&5
13205 +  ac_status=$?
13206 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13207    (exit $ac_status); }; }; then
13208    ac_cv_lib_mpi_MPI_Init=yes
13209   else
# Line 7193 | Line 13212 | fi
13212  
13213   ac_cv_lib_mpi_MPI_Init=no
13214   fi
13215 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
13215 > rm -f conftest.err conftest.$ac_objext \
13216 >      conftest$ac_exeext conftest.$ac_ext
13217   LIBS=$ac_check_lib_save_LIBS
13218   fi
13219   echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
# Line 7213 | Line 13233 | cat >conftest.$ac_ext <<_ACEOF
13233    ac_check_lib_save_LIBS=$LIBS
13234   LIBS="-lmpi "-llam" $LIBS"
13235   cat >conftest.$ac_ext <<_ACEOF
7216 #line $LINENO "configure"
13236   /* confdefs.h.  */
13237   _ACEOF
13238   cat confdefs.h >>conftest.$ac_ext
# Line 7227 | Line 13246 | char MPI_Init ();
13246   /* We use char because int might match the return type of a gcc2
13247     builtin and then its argument prototype would still apply.  */
13248   char MPI_Init ();
13249 + #ifdef FC_DUMMY_MAIN
13250 + #ifndef FC_DUMMY_MAIN_EQ_F77
13251 + #  ifdef __cplusplus
13252 +     extern "C"
13253 + #  endif
13254 +   int FC_DUMMY_MAIN() { return 1; }
13255 + #endif
13256 + #endif
13257   int
13258   main ()
13259   {
# Line 7237 | Line 13264 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13264   _ACEOF
13265   rm -f conftest.$ac_objext conftest$ac_exeext
13266   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13267 <  (eval $ac_link) 2>&5
13267 >  (eval $ac_link) 2>conftest.er1
13268    ac_status=$?
13269 +  grep -v '^ *+' conftest.er1 >conftest.err
13270 +  rm -f conftest.er1
13271 +  cat conftest.err >&5
13272    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13273    (exit $ac_status); } &&
13274 <         { ac_try='test -s conftest$ac_exeext'
13274 >         { ac_try='test -z "$ac_c_werror_flag"
13275 >                         || test ! -s conftest.err'
13276    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13277    (eval $ac_try) 2>&5
13278    ac_status=$?
13279    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13280 +  (exit $ac_status); }; } &&
13281 +         { ac_try='test -s conftest$ac_exeext'
13282 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13283 +  (eval $ac_try) 2>&5
13284 +  ac_status=$?
13285 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13286    (exit $ac_status); }; }; then
13287    ac_cv_lib_mpi_MPI_Init=yes
13288   else
# Line 7254 | Line 13291 | fi
13291  
13292   ac_cv_lib_mpi_MPI_Init=no
13293   fi
13294 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
13294 > rm -f conftest.err conftest.$ac_objext \
13295 >      conftest$ac_exeext conftest.$ac_ext
13296   LIBS=$ac_check_lib_save_LIBS
13297   fi
13298   echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
# Line 7274 | Line 13312 | cat >conftest.$ac_ext <<_ACEOF
13312    ac_check_lib_save_LIBS=$LIBS
13313   LIBS="-lmpich "-lpmpich" $LIBS"
13314   cat >conftest.$ac_ext <<_ACEOF
7277 #line $LINENO "configure"
13315   /* confdefs.h.  */
13316   _ACEOF
13317   cat confdefs.h >>conftest.$ac_ext
# Line 7288 | Line 13325 | char MPI_Init ();
13325   /* We use char because int might match the return type of a gcc2
13326     builtin and then its argument prototype would still apply.  */
13327   char MPI_Init ();
13328 + #ifdef FC_DUMMY_MAIN
13329 + #ifndef FC_DUMMY_MAIN_EQ_F77
13330 + #  ifdef __cplusplus
13331 +     extern "C"
13332 + #  endif
13333 +   int FC_DUMMY_MAIN() { return 1; }
13334 + #endif
13335 + #endif
13336   int
13337   main ()
13338   {
# Line 7298 | Line 13343 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13343   _ACEOF
13344   rm -f conftest.$ac_objext conftest$ac_exeext
13345   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13346 <  (eval $ac_link) 2>&5
13346 >  (eval $ac_link) 2>conftest.er1
13347    ac_status=$?
13348 +  grep -v '^ *+' conftest.er1 >conftest.err
13349 +  rm -f conftest.er1
13350 +  cat conftest.err >&5
13351    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13352    (exit $ac_status); } &&
13353 <         { ac_try='test -s conftest$ac_exeext'
13353 >         { ac_try='test -z "$ac_c_werror_flag"
13354 >                         || test ! -s conftest.err'
13355    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13356    (eval $ac_try) 2>&5
13357    ac_status=$?
13358    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13359 <  (exit $ac_status); }; }; then
13360 <  ac_cv_lib_mpich_MPI_Init=yes
7312 < else
7313 <  echo "$as_me: failed program was:" >&5
7314 < sed 's/^/| /' conftest.$ac_ext >&5
7315 <
7316 < ac_cv_lib_mpich_MPI_Init=no
7317 < fi
7318 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
7319 < LIBS=$ac_check_lib_save_LIBS
7320 < fi
7321 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
7322 < echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
7323 < if test $ac_cv_lib_mpich_MPI_Init = yes; then
7324 <  MPI_LIB="-lmpich -lpmpich"
7325 < fi
7326 <
7327 < fi
7328 <
7329 < $as_unset ac_cv_lib_mpi_MPI_Init
7330 < if test x = x"$MPI_LIB"; then
7331 < echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
7332 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
7333 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
7334 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7335 < else
7336 <  ac_check_lib_save_LIBS=$LIBS
7337 < LIBS="-lmpi -llam -lpthread $LIBS"
7338 < cat >conftest.$ac_ext <<_ACEOF
7339 < #line $LINENO "configure"
7340 < /* confdefs.h.  */
7341 < _ACEOF
7342 < cat confdefs.h >>conftest.$ac_ext
7343 < cat >>conftest.$ac_ext <<_ACEOF
7344 < /* end confdefs.h.  */
7345 <
7346 < /* Override any gcc2 internal prototype to avoid an error.  */
7347 < #ifdef __cplusplus
7348 < extern "C"
7349 < #endif
7350 < /* We use char because int might match the return type of a gcc2
7351 <   builtin and then its argument prototype would still apply.  */
7352 < char MPI_Init ();
7353 < int
7354 < main ()
7355 < {
7356 < MPI_Init ();
7357 <  ;
7358 <  return 0;
7359 < }
7360 < _ACEOF
7361 < rm -f conftest.$ac_objext conftest$ac_exeext
7362 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7363 <  (eval $ac_link) 2>&5
7364 <  ac_status=$?
7365 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7366 <  (exit $ac_status); } &&
7367 <         { ac_try='test -s conftest$ac_exeext'
13359 >  (exit $ac_status); }; } &&
13360 >         { ac_try='test -s conftest$ac_exeext'
13361    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13362    (eval $ac_try) 2>&5
13363    ac_status=$?
13364    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13365 <  (exit $ac_status); }; }; then
13366 <  ac_cv_lib_mpi_MPI_Init=yes
7374 < else
7375 <  echo "$as_me: failed program was:" >&5
7376 < sed 's/^/| /' conftest.$ac_ext >&5
7377 <
7378 < ac_cv_lib_mpi_MPI_Init=no
7379 < fi
7380 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
7381 < LIBS=$ac_check_lib_save_LIBS
7382 < fi
7383 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
7384 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
7385 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
7386 <  MPI_LIB="-lmpi -llam -lpthread"
7387 < else
7388 <
7389 <             { { echo "$as_me:$LINENO: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&5
7390 < echo "$as_me: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&2;}
7391 <   { (exit 1); exit 1; }; }
7392 <             USE_MPI="no"
7393 <
7394 < fi
7395 <
7396 < fi
7397 <
7398 <
7399 <
7400 < echo "$as_me:$LINENO: checking for MPI Fortran library" >&5
7401 < echo $ECHO_N "checking for MPI Fortran library... $ECHO_C" >&6
7402 < MPI_F90_LIB=""
7403 < if test -f "$MPI_LIB_DIR/libfmpich.a" ; then
7404 <        MPI_F90_LIB="-lfmpich"
7405 < elif test -f "$MPI_LIB_DIR/liblamf77mpi.a" ; then
7406 <        MPI_F90_LIB="-llamf77mpi"
7407 < else
7408 <                        MPI_F90_LIB="  "
7409 < fi
7410 < echo "$as_me:$LINENO: result: found $MPI_F90_LIB" >&5
7411 < echo "${ECHO_T}found $MPI_F90_LIB" >&6
7412 <
7413 <
7414 < fi
7415 <
7416 <
7417 <
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;
7425 <
7426 < case "x$with_sprng" in
7427 <        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
7435 <
7436 <
7437 < # Set variables...
7438 < SPRNG_LIB_DIR="$SPRNG/lib"
7439 < SPRNG_INC_DIR="$SPRNG/include"
7440 <
7441 <
7442 <
7443 < 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
13365 >  (exit $ac_status); }; }; then
13366 >  ac_cv_lib_mpich_MPI_Init=yes
13367   else
13368 <        echo "$as_me:$LINENO: result: no! Check SPRNG include path!" >&5
13369 < echo "${ECHO_T}no! Check SPRNG include path!" >&6
13370 <        USE_SPRNG="no"
13368 >  echo "$as_me: failed program was:" >&5
13369 > sed 's/^/| /' conftest.$ac_ext >&5
13370 >
13371 > ac_cv_lib_mpich_MPI_Init=no
13372   fi
13373 < rm -f conftest*
13374 < if test "$have_sprng_h" = 1; then
13373 > rm -f conftest.err conftest.$ac_objext \
13374 >      conftest$ac_exeext conftest.$ac_ext
13375 > LIBS=$ac_check_lib_save_LIBS
13376 > fi
13377 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13378 > echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13379 > if test $ac_cv_lib_mpich_MPI_Init = yes; then
13380 >  MPI_LIB="-lpmpich -lmpich"
13381 > fi
13382  
7459 cat >>confdefs.h <<\_ACEOF
7460 #define HAVE_SPRNG_H 1
7461 _ACEOF
7462
13383   fi
13384  
13385 < ac_ext=c
13386 < ac_cpp='$CPP $CPPFLAGS'
13387 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13388 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13389 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
7470 <
7471 < ac_save_LDFLAGS=$LDFLAGS
7472 < LDFLAGS="${LDFLAGS} -L${SPRNG_LIB_DIR} "
7473 <
7474 < echo "$as_me:$LINENO: checking for init_rng in -lsprng" >&5
7475 < echo $ECHO_N "checking for init_rng in -lsprng... $ECHO_C" >&6
7476 < if test "${ac_cv_lib_sprng_init_rng+set}" = set; then
13385 > $as_unset ac_cv_lib_mpi_MPI_Init
13386 > if test x = x"$MPI_LIB"; then
13387 > echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13388 > echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13389 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13390    echo $ECHO_N "(cached) $ECHO_C" >&6
13391   else
13392    ac_check_lib_save_LIBS=$LIBS
13393 < LIBS="-lsprng  $LIBS"
13393 > LIBS="-lmpi -llam -lpthread $LIBS"
13394   cat >conftest.$ac_ext <<_ACEOF
7482 #line $LINENO "configure"
13395   /* confdefs.h.  */
13396   _ACEOF
13397   cat confdefs.h >>conftest.$ac_ext
# Line 7492 | Line 13404 | extern "C"
13404   #endif
13405   /* We use char because int might match the return type of a gcc2
13406     builtin and then its argument prototype would still apply.  */
13407 < char init_rng ();
13407 > char MPI_Init ();
13408 > #ifdef FC_DUMMY_MAIN
13409 > #ifndef FC_DUMMY_MAIN_EQ_F77
13410 > #  ifdef __cplusplus
13411 >     extern "C"
13412 > #  endif
13413 >   int FC_DUMMY_MAIN() { return 1; }
13414 > #endif
13415 > #endif
13416   int
13417   main ()
13418   {
13419 < init_rng ();
13419 > MPI_Init ();
13420    ;
13421    return 0;
13422   }
13423   _ACEOF
13424   rm -f conftest.$ac_objext conftest$ac_exeext
13425   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13426 <  (eval $ac_link) 2>&5
13426 >  (eval $ac_link) 2>conftest.er1
13427    ac_status=$?
13428 +  grep -v '^ *+' conftest.er1 >conftest.err
13429 +  rm -f conftest.er1
13430 +  cat conftest.err >&5
13431    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13432    (exit $ac_status); } &&
13433 <         { ac_try='test -s conftest$ac_exeext'
13433 >         { ac_try='test -z "$ac_c_werror_flag"
13434 >                         || test ! -s conftest.err'
13435    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13436    (eval $ac_try) 2>&5
13437    ac_status=$?
13438    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13439 +  (exit $ac_status); }; } &&
13440 +         { ac_try='test -s conftest$ac_exeext'
13441 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13442 +  (eval $ac_try) 2>&5
13443 +  ac_status=$?
13444 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13445    (exit $ac_status); }; }; then
13446 <  ac_cv_lib_sprng_init_rng=yes
13446 >  ac_cv_lib_mpi_MPI_Init=yes
13447   else
13448    echo "$as_me: failed program was:" >&5
13449   sed 's/^/| /' conftest.$ac_ext >&5
13450  
13451 < ac_cv_lib_sprng_init_rng=no
13451 > ac_cv_lib_mpi_MPI_Init=no
13452   fi
13453 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
13453 > rm -f conftest.err conftest.$ac_objext \
13454 >      conftest$ac_exeext conftest.$ac_ext
13455   LIBS=$ac_check_lib_save_LIBS
13456   fi
13457 < echo "$as_me:$LINENO: result: $ac_cv_lib_sprng_init_rng" >&5
13458 < echo "${ECHO_T}$ac_cv_lib_sprng_init_rng" >&6
13459 < if test $ac_cv_lib_sprng_init_rng = yes; then
13460 <  SPRNG_LIB="-lsprng"
13457 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13458 > echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13459 > if test $ac_cv_lib_mpi_MPI_Init = yes; then
13460 >  MPI_LIB="-lmpi -llam -lpthread"
13461   else
13462  
13463 <             { { echo "$as_me:$LINENO: error: Didn't find libsprng; check path for SPRNG package first..." >&5
13464 < echo "$as_me: error: Didn't find libsprng; check path for SPRNG package first..." >&2;}
13463 >             { { echo "$as_me:$LINENO: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&5
13464 > echo "$as_me: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&2;}
13465     { (exit 1); exit 1; }; }
13466 <             USE_SPRNG="no"
13466 >             USE_MPI="no"
13467  
13468   fi
13469  
13470 + fi
13471  
13472 < if test "$USE_SPRNG" = "no"; then
13473 <  { { echo "$as_me:$LINENO: error: No working SPRNG library found" >&5
13474 < echo "$as_me: error: No working SPRNG library found" >&2;}
13475 <   { (exit 1); exit 1; }; }
13472 >
13473 >
13474 > echo "$as_me:$LINENO: checking for MPI Fortran library" >&5
13475 > echo $ECHO_N "checking for MPI Fortran library... $ECHO_C" >&6
13476 > MPI_F90_LIB=""
13477 > if test -f "$MPI_LIB_DIR/libfmpich.a" ; then
13478 >        MPI_F90_LIB="-lfmpich"
13479 > elif test -f "$MPI_LIB_DIR/liblamf77mpi.a" ; then
13480 >        MPI_F90_LIB="-llamf77mpi"
13481 > else
13482 >                        MPI_F90_LIB="  "
13483   fi
13484 + echo "$as_me:$LINENO: result: found $MPI_F90_LIB" >&5
13485 + echo "${ECHO_T}found $MPI_F90_LIB" >&6
13486  
13487  
13488   fi
13489  
13490  
13491  
13492 < echo "$as_me:$LINENO: checking if MKL is wanted" >&5
13493 < echo $ECHO_N "checking if MKL is wanted... $ECHO_C" >&6
13492 > USE_CGAL=no
13493 > cgal_makefile=auto
13494  
13495 < # Check whether --with-mkl or --without-mkl was given.
13496 < if test "${with_mkl+set}" = set; then
13497 <  withval="$with_mkl"
13498 <     echo "$as_me:$LINENO: result: yes" >&5
13499 < echo "${ECHO_T}yes" >&6
13500 <    for dir in $withval /usr/local/intel/mkl61 /opt/intel/mkl61; do
13501 <        mkldir="$dir"
13502 <        if test -f "$dir/include/mkl.h"; then
13503 <            found_mkl="yes";
13504 <            break;
13505 <        fi
13506 <    done
13507 <    if test x_$found_mkl != x_yes; then
13508 <        { { echo "$as_me:$LINENO: error: Cannot find MKL includes" >&5
13509 < echo "$as_me: error: Cannot find MKL includes" >&2;}
13510 <   { (exit 1); exit 1; }; }
13511 <    else
13512 <        printf "MKL includes found in $mkldir/include\n";
13495 > # Check whether --with-cgal-makefile or --without-cgal-makefile was given.
13496 > if test "${with_cgal_makefile+set}" = set; then
13497 >  withval="$with_cgal_makefile"
13498 >  cgal_makefile="$withval"
13499 > fi;
13500 >
13501 > if test "x$cgal_makefile" != xno; then
13502 >
13503 >  if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
13504 >    cgal_makefile="$CGAL_MAKEFILE"
13505 >  fi
13506 >
13507 >  echo "$as_me:$LINENO: checking for cgal_makefile: $cgal_makefile" >&5
13508 > echo $ECHO_N "checking for cgal_makefile: $cgal_makefile... $ECHO_C" >&6
13509 >
13510 >  if test -f "$cgal_makefile"; then
13511 >
13512 >    cat >config.tmp.Makefile <<EOF
13513 > include $cgal_makefile
13514 > default:
13515 >        @echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
13516 >        @echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
13517 >        @echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
13518 >        @echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13519 >        @echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13520 >        @echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
13521 >        @echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
13522 >        @echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13523 >        @echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13524 >        @echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
13525 >        @echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13526 >        @echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13527 > EOF
13528 >
13529 >    make -s -f config.tmp.Makefile
13530 >    . config.tmp.cgalvariables
13531 >
13532 >    rm -f config.tmp.Makefile config.tmp.cgalvariables
13533 >
13534 >    if test "x$CGAL_INCLDIR" = "x"; then
13535 >      CGAL_INCLDIR=""
13536      fi
13537  
13538 +    if test "x$CGAL_LIBDIR" = "x"; then
13539 +      CGAL_LIBDIR=""
13540 +    fi
13541  
13542 +    if test "x$CGAL_RLIBDIR" = "x"; then
13543 +      CGAL_RLIBDIR=""
13544 +    fi
13545  
13546 <  ac_ext=c
13547 < ac_cpp='$CPP $CPPFLAGS'
13548 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7579 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7580 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
13546 >    if test "x$LEDA_INCLDIR" = "x"; then
13547 >      LEDA_INCLDIR=""
13548 >    fi
13549  
13550 <  ac_save_CPPFLAGS=$CPPFLAGS
13551 <  CPPFLAGS="${CPPFLAGS} -I${mkldir}/include"
13552 <  ac_save_LDFLAGS=$LDFLAGS
13553 <  LDFLAGS="${LDFLAGS} -L${mkldir}/lib/32 -lmkl -lvml -lguide"
13554 <  if test "${ac_cv_header_mkl_h+set}" = set; then
13555 <  echo "$as_me:$LINENO: checking for mkl.h" >&5
13556 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
13557 < if test "${ac_cv_header_mkl_h+set}" = set; then
13550 >    if test "x$LEDA_LIBDIR" = "x"; then
13551 >      LEDA_LIBDIR=""
13552 >    fi
13553 >
13554 >    if test "x$LEDA_RLIBDIR" = "x"; then
13555 >      LEDA_RLIBDIR=""
13556 >    fi
13557 >
13558 >    if test "x$GMP_INCLDIR" = "x"; then
13559 >      GMP_INCLDIR=""
13560 >    fi
13561 >
13562 >    if test "x$GMP_LIBDIR" = "x"; then
13563 >      GMP_LIBDIR=""
13564 >    fi
13565 >
13566 >    if test "x$GMP_RLIBDIR" = "x"; then
13567 >      GMP_RLIBDIR=""
13568 >    fi
13569 >
13570 >    echo "$as_me:$LINENO: result: CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&5
13571 > echo "${ECHO_T}CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&6
13572 >    echo "$as_me:$LINENO: result: CGAL_INCLDIR=       $CGAL_INCLDIR" >&5
13573 > echo "${ECHO_T}CGAL_INCLDIR=       $CGAL_INCLDIR" >&6
13574 >    echo "$as_me:$LINENO: result: CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&5
13575 > echo "${ECHO_T}CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&6
13576 >    echo "$as_me:$LINENO: result: CGAL_LIBDIR=        $CGAL_LIBDIR" >&5
13577 > echo "${ECHO_T}CGAL_LIBDIR=        $CGAL_LIBDIR" >&6
13578 >    echo "$as_me:$LINENO: result: CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&5
13579 > echo "${ECHO_T}CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&6
13580 >    echo "$as_me:$LINENO: result: LEDA_INCLDIR=       $LEDA_INCLDIR" >&5
13581 > echo "${ECHO_T}LEDA_INCLDIR=       $LEDA_INCLDIR" >&6
13582 >    echo "$as_me:$LINENO: result: LEDA_LIBDIR=        $LEDA_LIBDIR" >&5
13583 > echo "${ECHO_T}LEDA_LIBDIR=        $LEDA_LIBDIR" >&6
13584 >    echo "$as_me:$LINENO: result: GMP_INCLDIR=        $GMP_INCLDIR" >&5
13585 > echo "${ECHO_T}GMP_INCLDIR=        $GMP_INCLDIR" >&6
13586 >    echo "$as_me:$LINENO: result: GMP_LIBDIR=         $GMP_LIBDIR" >&5
13587 > echo "${ECHO_T}GMP_LIBDIR=         $GMP_LIBDIR" >&6
13588 >
13589 >    ac_ext=cc
13590 > ac_cpp='$CXXCPP $CPPFLAGS'
13591 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13592 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13593 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13594 >
13595 >    save_CXXFLAGS="$CXXFLAGS"
13596 >    CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13597 >    if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13598 >  echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13599 > echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13600 > if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13601    echo $ECHO_N "(cached) $ECHO_C" >&6
13602   fi
13603 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
13604 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
13603 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13604 > echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13605   else
13606    # Is the header compilable?
13607 < echo "$as_me:$LINENO: checking mkl.h usability" >&5
13608 < echo $ECHO_N "checking mkl.h usability... $ECHO_C" >&6
13607 > echo "$as_me:$LINENO: checking CGAL/Cartesian.h usability" >&5
13608 > echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
13609   cat >conftest.$ac_ext <<_ACEOF
7599 #line $LINENO "configure"
13610   /* confdefs.h.  */
13611   _ACEOF
13612   cat confdefs.h >>conftest.$ac_ext
13613   cat >>conftest.$ac_ext <<_ACEOF
13614   /* end confdefs.h.  */
13615   $ac_includes_default
13616 < #include <mkl.h>
13616 > #include <CGAL/Cartesian.h>
13617   _ACEOF
13618   rm -f conftest.$ac_objext
13619   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13620 <  (eval $ac_compile) 2>&5
13620 >  (eval $ac_compile) 2>conftest.er1
13621    ac_status=$?
13622 +  grep -v '^ *+' conftest.er1 >conftest.err
13623 +  rm -f conftest.er1
13624 +  cat conftest.err >&5
13625    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13626    (exit $ac_status); } &&
13627 <         { ac_try='test -s conftest.$ac_objext'
13627 >         { ac_try='test -z "$ac_cxx_werror_flag"
13628 >                         || test ! -s conftest.err'
13629    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13630    (eval $ac_try) 2>&5
13631    ac_status=$?
13632    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13633 +  (exit $ac_status); }; } &&
13634 +         { ac_try='test -s conftest.$ac_objext'
13635 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13636 +  (eval $ac_try) 2>&5
13637 +  ac_status=$?
13638 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13639    (exit $ac_status); }; }; then
13640    ac_header_compiler=yes
13641   else
# Line 7624 | Line 13644 | fi
13644  
13645   ac_header_compiler=no
13646   fi
13647 < rm -f conftest.$ac_objext conftest.$ac_ext
13647 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
13648   echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
13649   echo "${ECHO_T}$ac_header_compiler" >&6
13650  
13651   # Is the header present?
13652 < echo "$as_me:$LINENO: checking mkl.h presence" >&5
13653 < echo $ECHO_N "checking mkl.h presence... $ECHO_C" >&6
13652 > echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
13653 > echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
13654   cat >conftest.$ac_ext <<_ACEOF
7635 #line $LINENO "configure"
13655   /* confdefs.h.  */
13656   _ACEOF
13657   cat confdefs.h >>conftest.$ac_ext
13658   cat >>conftest.$ac_ext <<_ACEOF
13659   /* end confdefs.h.  */
13660 < #include <mkl.h>
13660 > #include <CGAL/Cartesian.h>
13661   _ACEOF
13662   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
13663    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 7649 | Line 13668 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
13668    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13669    (exit $ac_status); } >/dev/null; then
13670    if test -s conftest.err; then
13671 <    ac_cpp_err=$ac_c_preproc_warn_flag
13671 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
13672 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
13673    else
13674      ac_cpp_err=
13675    fi
# Line 7669 | Line 13689 | echo "${ECHO_T}$ac_header_preproc" >&6
13689   echo "${ECHO_T}$ac_header_preproc" >&6
13690  
13691   # So?  What about this header?
13692 < case $ac_header_compiler:$ac_header_preproc in
13693 <  yes:no )
13694 <    { echo "$as_me:$LINENO: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&5
13695 < echo "$as_me: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13696 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the preprocessor's result" >&5
13697 < echo "$as_me: WARNING: mkl.h: proceeding with the preprocessor's result" >&2;}
13698 <    (
7679 <      cat <<\_ASBOX
7680 < ## ------------------------------------ ##
7681 < ## Report this to bug-autoconf@gnu.org. ##
7682 < ## ------------------------------------ ##
7683 < _ASBOX
7684 <    ) |
7685 <      sed "s/^/$as_me: WARNING:     /" >&2
13692 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13693 >  yes:no: )
13694 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
13695 > echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13696 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
13697 > echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
13698 >    ac_header_preproc=yes
13699      ;;
13700 <  no:yes )
13701 <    { echo "$as_me:$LINENO: WARNING: mkl.h: present but cannot be compiled" >&5
13702 < echo "$as_me: WARNING: mkl.h: present but cannot be compiled" >&2;}
13703 <    { echo "$as_me:$LINENO: WARNING: mkl.h: check for missing prerequisite headers?" >&5
13704 < echo "$as_me: WARNING: mkl.h: check for missing prerequisite headers?" >&2;}
13705 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the preprocessor's result" >&5
13706 < echo "$as_me: WARNING: mkl.h: proceeding with the preprocessor's result" >&2;}
13700 >  no:yes:* )
13701 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&5
13702 > echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
13703 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
13704 > echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
13705 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
13706 > echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
13707 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
13708 > echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13709 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
13710 > echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
13711 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
13712 > echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
13713      (
13714        cat <<\_ASBOX
13715 < ## ------------------------------------ ##
13716 < ## Report this to bug-autoconf@gnu.org. ##
13717 < ## ------------------------------------ ##
13715 > ## ------------------------------ ##
13716 > ## Report this to gezelter@nd.edu ##
13717 > ## ------------------------------ ##
13718   _ASBOX
13719      ) |
13720        sed "s/^/$as_me: WARNING:     /" >&2
13721      ;;
13722   esac
13723 < echo "$as_me:$LINENO: checking for mkl.h" >&5
13724 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
13725 < if test "${ac_cv_header_mkl_h+set}" = set; then
13723 > echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13724 > echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13725 > if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13726    echo $ECHO_N "(cached) $ECHO_C" >&6
13727   else
13728 <  ac_cv_header_mkl_h=$ac_header_preproc
13728 >  ac_cv_header_CGAL_Cartesian_h=$ac_header_preproc
13729   fi
13730 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
13731 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
13730 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13731 > echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13732  
13733   fi
13734 < if test $ac_cv_header_mkl_h = yes; then
13735 <
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
13734 > if test $ac_cv_header_CGAL_Cartesian_h = yes; then
13735 >  cgal=yes
13736   else
13737 <  ac_check_lib_save_LIBS=$LIBS
13738 < LIBS="-lmkl  $LIBS"
13737 >  cgal=no
13738 > fi
13739 >
13740 >
13741 >    CXXFLAGS="$save_CXXFLAGS"
13742 >
13743 >    if test "x$cgal" = xyes; then
13744 >      echo "$as_me:$LINENO: checking for CGAL version" >&5
13745 > echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
13746 >      LOCATION=${CGAL_INCLDIR}
13747 >      LOCATION=${LOCATION:-/usr/include}
13748 >      if test -f $LOCATION/CGAL/version.h; then
13749 >        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
13750 >      else
13751 >        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
13752 >      fi
13753 >      if echo $CGAL_VERSION | grep -q "^[3456789]"; then
13754 >        echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
13755 > echo "${ECHO_T}($CGAL_VERSION) yes" >&6
13756 >      else
13757 >        echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
13758 > echo "${ECHO_T}($CGAL_VERSION) no" >&6
13759 >        cgal=no
13760 >      fi
13761 >    fi
13762 >
13763 >    if test "x$cgal" = xyes; then
13764 >      CGAL_LIBS="-lCGAL"
13765 >      echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
13766 > echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
13767 >      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
13768 >        CGAL_USES_LEDA=yes
13769 >        echo "$as_me:$LINENO: result: yes" >&5
13770 > echo "${ECHO_T}yes" >&6
13771 >        CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
13772 >      else
13773 >        echo "$as_me:$LINENO: result: no" >&5
13774 > echo "${ECHO_T}no" >&6
13775 >        CGAL_USES_LEDA=no
13776 >      fi
13777 >
13778 >      echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
13779 > echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
13780 >      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
13781 >        CGAL_USES_GMP=yes
13782 >        echo "$as_me:$LINENO: result: yes" >&5
13783 > echo "${ECHO_T}yes" >&6
13784 >        CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
13785 >      else
13786 >        echo "$as_me:$LINENO: result: no" >&5
13787 > echo "${ECHO_T}no" >&6
13788 >        CGAL_USES_GMP=no
13789 >      fi
13790 >
13791 >      CGAL_LIBS="$CGAL_LIBS -lm"
13792 >
13793 >      CGAL_CXXFLAGS="-ftemplate-depth-50"
13794 >
13795 >      echo "$as_me:$LINENO: result: CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&5
13796 > echo "${ECHO_T}CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&6
13797 >      echo "$as_me:$LINENO: result: CGAL_USES_GMP =     $CGAL_USES_GMP" >&5
13798 > echo "${ECHO_T}CGAL_USES_GMP =     $CGAL_USES_GMP" >&6
13799 >      echo "$as_me:$LINENO: result: CGAL_INCLDIR  =     $CGAL_INCLDIR" >&5
13800 > echo "${ECHO_T}CGAL_INCLDIR  =     $CGAL_INCLDIR" >&6
13801 >      echo "$as_me:$LINENO: result: CGAL_LIBDIR   =     $CGAL_LIBDIR" >&5
13802 > echo "${ECHO_T}CGAL_LIBDIR   =     $CGAL_LIBDIR" >&6
13803 >      echo "$as_me:$LINENO: result: CGAL_DEFINES  =     $CGAL_DEFINES" >&5
13804 > echo "${ECHO_T}CGAL_DEFINES  =     $CGAL_DEFINES" >&6
13805 >      echo "$as_me:$LINENO: result: CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&5
13806 > echo "${ECHO_T}CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&6
13807 >      echo "$as_me:$LINENO: result: CGAL_LIBS     =     $CGAL_LIBS" >&5
13808 > echo "${ECHO_T}CGAL_LIBS     =     $CGAL_LIBS" >&6
13809 >    fi
13810 >
13811 >    if test "x$cgal" = xyes; then
13812 >      save_LIBS="$LIBS"
13813 >      LIBS="$LIBS -L$CGAL_LIBDIR"
13814 >      if test "x$CGAL_USES_LEDA" = xyes; then
13815 >        LIBS="-lL $LIBS -L$LEDA_LIBDIR"
13816 >      fi
13817 >      # if test "x$CGAL_USES_GMP" = xyes; then
13818 >      #   LIBS="-lgmp $LIBS $GMP_LIBDIR"
13819 >      # fi
13820 >      echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
13821 > echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
13822 > save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
13823 > CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13824 > save_LIBS_CHECK_CXX_LIB="$LIBS"
13825 > LIBS="-lCGAL  $LIBS"
13826   cat >conftest.$ac_ext <<_ACEOF
7725 #line $LINENO "configure"
13827   /* confdefs.h.  */
13828   _ACEOF
13829   cat confdefs.h >>conftest.$ac_ext
13830   cat >>conftest.$ac_ext <<_ACEOF
13831   /* end confdefs.h.  */
13832 <
13833 < /* Override any gcc2 internal prototype to avoid an error.  */
13834 < #ifdef __cplusplus
13835 < extern "C"
13832 > #include <CGAL/Cartesian.h>
13833 > #ifdef FC_DUMMY_MAIN
13834 > #ifndef FC_DUMMY_MAIN_EQ_F77
13835 > #  ifdef __cplusplus
13836 >     extern "C"
13837 > #  endif
13838 >   int FC_DUMMY_MAIN() { return 1; }
13839   #endif
13840 < /* 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 ();
13840 > #endif
13841   int
13842   main ()
13843   {
13844 < vslNewStream ();
13844 > ::CGAL::Cartesian<int>::Point_2 P
13845    ;
13846    return 0;
13847   }
13848   _ACEOF
13849   rm -f conftest.$ac_objext conftest$ac_exeext
13850   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13851 <  (eval $ac_link) 2>&5
13851 >  (eval $ac_link) 2>conftest.er1
13852    ac_status=$?
13853 +  grep -v '^ *+' conftest.er1 >conftest.err
13854 +  rm -f conftest.er1
13855 +  cat conftest.err >&5
13856    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13857    (exit $ac_status); } &&
13858 <         { ac_try='test -s conftest$ac_exeext'
13858 >         { ac_try='test -z "$ac_cxx_werror_flag"
13859 >                         || test ! -s conftest.err'
13860    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13861    (eval $ac_try) 2>&5
13862    ac_status=$?
13863    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13864 +  (exit $ac_status); }; } &&
13865 +         { ac_try='test -s conftest$ac_exeext'
13866 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13867 +  (eval $ac_try) 2>&5
13868 +  ac_status=$?
13869 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13870    (exit $ac_status); }; }; then
13871 <  ac_cv_lib_mkl_vslNewStream=yes
13871 >  echo "$as_me:$LINENO: result: yes" >&5
13872 > echo "${ECHO_T}yes" >&6
13873 > cgal=yes
13874   else
13875    echo "$as_me: failed program was:" >&5
13876   sed 's/^/| /' conftest.$ac_ext >&5
13877  
13878 < ac_cv_lib_mkl_vslNewStream=no
13878 > echo "$as_me:$LINENO: result: no" >&5
13879 > echo "${ECHO_T}no" >&6
13880 > cgal=no
13881   fi
13882 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
13883 < LIBS=$ac_check_lib_save_LIBS
13884 < fi
13885 < echo "$as_me:$LINENO: result: $ac_cv_lib_mkl_vslNewStream" >&5
13886 < echo "${ECHO_T}$ac_cv_lib_mkl_vslNewStream" >&6
13887 < 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"
7780 < fi
13882 > rm -f conftest.err conftest.$ac_objext \
13883 >      conftest$ac_exeext conftest.$ac_ext
13884 > CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
13885 > LIBS="$save_LIBS_CHECK_CXX_LIB"
13886 >      LIBS="$save_LIBS"
13887 >    fi
13888  
13889 <
7783 <  CPPFLAGS=$ac_save_CPPFLAGS
7784 <  LDFLAGS=$ac_save_LDFLAGS
13889 >  fi
13890    ac_ext=c
13891   ac_cpp='$CPP $CPPFLAGS'
13892   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 7789 | Line 13894 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
13894   ac_compiler_gnu=$ac_cv_c_compiler_gnu
13895  
13896  
13897 <  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
13897 > fi
13898  
13899 + if test "x$cgal" = xyes; then
13900 +  USE_CGAL=yes
13901  
13902 + cat >>confdefs.h <<\_ACEOF
13903 + #define HAVE_CGAL 1
13904 + _ACEOF
13905  
13906  
13907 + cat >>confdefs.h <<_ACEOF
13908 + #define CGAL_VERSION $CGAL_VERSION
13909 + _ACEOF
13910  
13911 +  if ! echo $CGAL_VERSION | grep -q "^3.0"; then
13912 +    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
13913 + echo "$as_me: WARNING: *****************************************************" >&2;}
13914 +    { echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
13915 + echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
13916 +    { echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
13917 + echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
13918 +    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
13919 + echo "$as_me: WARNING: *****************************************************" >&2;}
13920 +  fi
13921   else
13922 +   if test "x$cgal_makefile" != xno; then
13923 +    echo "$as_me:$LINENO: result: No CGAL support. These are not the droids you want." >&5
13924 + echo "${ECHO_T}No CGAL support. These are not the droids you want." >&6
13925 +  fi
13926 +  CGAL_INCLDIR=
13927 +  CGAL_LIBDIR=
13928 +  CGAL_RLIBDIR=
13929 +  CGAL_DEFINES=
13930 +  CGAL_CXXFLAGS=
13931 +  CGAL_LIBS=
13932 + fi
13933  
7804    echo "$as_me:$LINENO: result: no" >&5
7805 echo "${ECHO_T}no" >&6
13934  
13935 < fi;
13935 > CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
13936  
13937 + CGAL_LIB_DIR=${CGAL_LIBDIR}
13938  
13939 + CGAL_RLIB_DIR=${CGAL_RLIBDIR}
13940  
13941 +
13942 +
13943 +
13944 +
13945 +
13946   # Check whether --enable-doxygen or --disable-doxygen was given.
13947   if test "${enable_doxygen+set}" = set; then
13948    enableval="$enable_doxygen"
# Line 7949 | Line 14084 | fi
14084  
14085  
14086  
7952 OBJEXT=".$OBJEXT"
14087  
7954 OOPSE=oopse
14088  
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;
14089  
7968 case "x$INSTALL" in
7969   x/*) ;;
7970   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
7971 esac
14090  
7973 MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14091  
7975 CFLAGS=${CFLAGS-""}
7976 CXXFLAGS=${CXXFLAGS-""}
7977 CPPFLAGS=${CPPFLAGS-""}
7978 FFLAGS=${FFLAGS-""}
7979 F90FLAGS=${F90FLAGS-""}
7980 LDFLAGS=${LDFLAGS-""}
7981 DEBUG=${DEBUG-"-g"}
14092  
7983 case $debug in
7984  1)
7985     FFLAGS="$DEBUG $FFLAGS"
7986     F90FLAGS="$DEBUG $F90FLAGS"
7987     ;;
7988  *)
7989     ;;
7990 esac
14093  
14094  
14095  
14096  
14097  
14098  
14099 <
7998 <
7999 <
8000 <
8001 <
8002 <
8003 <
14099 >                                        ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14100  
14101  
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
14102   cat >confcache <<\_ACEOF
14103   # This file is a shell script that caches the results of configure
14104   # tests run on this system so they can be shared between configure
# Line 8039 | Line 14127 | _ACEOF
14127        # `set' does not quote correctly, so add quotes (double-quote
14128        # substitution turns \\\\ into \\, and sed turns \\ into \).
14129        sed -n \
14130 <        "s/'/'\\\\''/g;
14131 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
14130 >        "s/'/'\\\\''/g;
14131 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
14132        ;;
14133      *)
14134        # `set' quotes correctly as required by POSIX, so do not add quotes.
14135        sed -n \
14136 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
14136 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
14137        ;;
14138      esac;
14139   } |
# Line 8075 | Line 14163 | if test "x$srcdir" = x.; then
14163   # trailing colons and then remove the whole line if VPATH becomes empty
14164   # (actually we leave an empty line to preserve line numbers).
14165   if test "x$srcdir" = x.; then
14166 <  ac_vpsub='/^[         ]*VPATH[        ]*=/{
14166 >  ac_vpsub='/^[  ]*VPATH[        ]*=/{
14167   s/:*\$(srcdir):*/:/;
14168   s/:*\${srcdir}:*/:/;
14169   s/:*@srcdir@:*/:/;
14170 < s/^\([^=]*=[    ]*\):*/\1/;
14170 > s/^\([^=]*=[     ]*\):*/\1/;
14171   s/:*$//;
14172 < s/^[^=]*=[      ]*$//;
14172 > s/^[^=]*=[       ]*$//;
14173   }'
14174   fi
14175  
# Line 8092 | Line 14180 | for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && conti
14180   for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
14181    # 1. Remove the extension, and $U if already installed.
14182    ac_i=`echo "$ac_i" |
14183 <         sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
14183 >         sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
14184    # 2. Add them.
14185    ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
14186    ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
# Line 8136 | Line 14224 | fi
14224   elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
14225    set -o posix
14226   fi
14227 + DUALCASE=1; export DUALCASE # for MKS sh
14228  
14229   # Support unset when possible.
14230 < if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
14230 > if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
14231    as_unset=unset
14232   else
14233    as_unset=false
# Line 8157 | Line 14246 | do
14246    LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
14247    LC_TELEPHONE LC_TIME
14248   do
14249 <  if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then
14249 >  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
14250      eval $as_var=C; export $as_var
14251    else
14252      $as_unset $as_var
# Line 8336 | Line 14425 | else
14425   if mkdir -p . 2>/dev/null; then
14426    as_mkdir_p=:
14427   else
14428 +  test -d ./-p && rmdir ./-p
14429    as_mkdir_p=false
14430   fi
14431  
14432   as_executable_p="test -f"
14433  
14434   # Sed expression to map a string onto a valid CPP name.
14435 < as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
14435 > as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
14436  
14437   # Sed expression to map a string onto a valid variable name.
14438 < as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
14438 > as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
14439  
14440  
14441   # IFS
# Line 8371 | Line 14461 | cat >&5 <<_CSEOF
14461   } >&5
14462   cat >&5 <<_CSEOF
14463  
14464 < This file was extended by OOPSE $as_me 2.0, which was
14465 < generated by GNU Autoconf 2.57.  Invocation command line was
14464 > This file was extended by OOPSE $as_me 3.0, which was
14465 > generated by GNU Autoconf 2.59.  Invocation command line was
14466  
14467    CONFIG_FILES    = $CONFIG_FILES
14468    CONFIG_HEADERS  = $CONFIG_HEADERS
# Line 8416 | Line 14506 | Usage: $0 [OPTIONS] [FILE]...
14506    -d, --debug      don't remove temporary files
14507        --recheck    update $as_me by reconfiguring in the same conditions
14508    --file=FILE[:TEMPLATE]
14509 <                   instantiate the configuration file FILE
14509 >                   instantiate the configuration file FILE
14510    --header=FILE[:TEMPLATE]
14511 <                   instantiate the configuration header FILE
14511 >                   instantiate the configuration header FILE
14512  
14513   Configuration files:
14514   $config_files
# Line 8434 | Line 14524 | ac_cs_version="\\
14524  
14525   cat >>$CONFIG_STATUS <<_ACEOF
14526   ac_cs_version="\\
14527 < OOPSE config.status 2.0
14528 < configured by $0, generated by GNU Autoconf 2.57,
14527 > OOPSE config.status 3.0
14528 > configured by $0, generated by GNU Autoconf 2.59,
14529    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14530  
14531 < Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
8442 < Free Software Foundation, Inc.
14531 > Copyright (C) 2003 Free Software Foundation, Inc.
14532   This config.status script is free software; the Free Software Foundation
14533   gives unlimited permission to copy, distribute and modify it."
14534   srcdir=$srcdir
# Line 8540 | Line 14629 | do
14629    # Handling of arguments.
14630    "make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14631    "src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
14632 +  "src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
14633 +  "scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
14634    "src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
14635    "src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
14636    *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
# Line 8627 | Line 14718 | s,@LIBS@,$LIBS,;t t
14718   s,@ECHO_N@,$ECHO_N,;t t
14719   s,@ECHO_T@,$ECHO_T,;t t
14720   s,@LIBS@,$LIBS,;t t
8630 s,@PROGNAME@,$PROGNAME,;t t
8631 s,@debug@,$debug,;t t
14721   s,@build@,$build,;t t
14722   s,@build_cpu@,$build_cpu,;t t
14723   s,@build_vendor@,$build_vendor,;t t
# Line 8637 | Line 14726 | s,@host_os@,$host_os,;t t
14726   s,@host_cpu@,$host_cpu,;t t
14727   s,@host_vendor@,$host_vendor,;t t
14728   s,@host_os@,$host_os,;t t
14729 < s,@CC@,$CC,;t t
14730 < s,@CFLAGS@,$CFLAGS,;t t
14729 > s,@PROGNAME@,$PROGNAME,;t t
14730 > s,@debug@,$debug,;t t
14731 > s,@CXX@,$CXX,;t t
14732 > s,@CXXFLAGS@,$CXXFLAGS,;t t
14733   s,@LDFLAGS@,$LDFLAGS,;t t
14734   s,@CPPFLAGS@,$CPPFLAGS,;t t
14735 < s,@ac_ct_CC@,$ac_ct_CC,;t t
14735 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14736   s,@EXEEXT@,$EXEEXT,;t t
14737   s,@OBJEXT@,$OBJEXT,;t t
14738 < s,@CXX@,$CXX,;t t
14739 < s,@CXXFLAGS@,$CXXFLAGS,;t t
14740 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14741 < s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
14742 < s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
14743 < 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
14738 > s,@CC@,$CC,;t t
14739 > s,@CFLAGS@,$CFLAGS,;t t
14740 > s,@ac_ct_CC@,$ac_ct_CC,;t t
14741 > s,@FC@,$FC,;t t
14742 > s,@FCFLAGS@,$FCFLAGS,;t t
14743 > s,@ac_ct_FC@,$ac_ct_FC,;t t
14744   s,@CPP@,$CPP,;t t
14745   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
14746   s,@LN_S@,$LN_S,;t t
14747   s,@SET_MAKE@,$SET_MAKE,;t t
14748   s,@RANLIB@,$RANLIB,;t t
14749   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
14750 < s,@YACC@,$YACC,;t t
14751 < s,@LEX@,$LEX,;t t
14752 < s,@LEXLIB@,$LEXLIB,;t t
14753 < s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
14750 > s,@PERLINTERP@,$PERLINTERP,;t t
14751 > s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
14752 > s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
14753 > s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
14754 > s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14755   s,@AR@,$AR,;t t
14756   s,@PS@,$PS,;t t
14757 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
14758 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
14759 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
14760 + s,@FCLIBS@,$FCLIBS,;t t
14761 + s,@FC_FUNC@,$FC_FUNC,;t t
14762 + s,@FC_FUNC_@,$FC_FUNC_,;t t
14763 + s,@MOD@,$MOD,;t t
14764 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
14765 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
14766 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14767 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14768 + s,@ZLIB_INC_DIR@,$ZLIB_INC_DIR,;t t
14769 + s,@ZLIB_LIB_DIR@,$ZLIB_LIB_DIR,;t t
14770 + s,@ZLIB@,$ZLIB,;t t
14771 + s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
14772 + s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
14773 + s,@FFTW_LIBS@,$FFTW_LIBS,;t t
14774 + s,@LIBOBJS@,$LIBOBJS,;t t
14775 + s,@POW_LIB@,$POW_LIB,;t t
14776 + s,@CXXCPP@,$CXXCPP,;t t
14777 + s,@__func__@,$__func__,;t t
14778   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
14779   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
14780   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
14781   s,@MPI_LIB@,$MPI_LIB,;t t
14782   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
14783   s,@USE_MPI@,$USE_MPI,;t t
14784 < s,@SPRNG_LIB_DIR@,$SPRNG_LIB_DIR,;t t
14785 < s,@SPRNG_INC_DIR@,$SPRNG_INC_DIR,;t t
14786 < s,@SPRNG_LIB@,$SPRNG_LIB,;t t
14787 < s,@USE_SPRNG@,$USE_SPRNG,;t t
14788 < s,@MKL_LIBDIR@,$MKL_LIBDIR,;t t
14789 < s,@MKL_LIB@,$MKL_LIB,;t t
14790 < s,@MKL_INC@,$MKL_INC,;t t
8694 < s,@HAVE_MKL@,$HAVE_MKL,;t t
14784 > s,@USE_CGAL@,$USE_CGAL,;t t
14785 > s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
14786 > s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
14787 > s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
14788 > s,@CGAL_DEFINES@,$CGAL_DEFINES,;t t
14789 > s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
14790 > s,@CGAL_LIBS@,$CGAL_LIBS,;t t
14791   s,@DOXYGEN@,$DOXYGEN,;t t
14792   s,@DOT@,$DOT,;t t
14793   s,@DOC@,$DOC,;t t
# Line 8703 | Line 14799 | s,@SUBDIRS@,$SUBDIRS,;t t
14799   s,@OOPSE@,$OOPSE,;t t
14800   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
14801   s,@SUBDIRS@,$SUBDIRS,;t t
8706 s,@FFLAGS@,$FFLAGS,;t t
14802   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
14803   CEOF
14804  
# Line 8734 | Line 14829 | _ACEOF
14829        (echo ':t
14830    /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
14831        if test -z "$ac_sed_cmds"; then
14832 <        ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
14832 >        ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
14833        else
14834 <        ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
14834 >        ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
14835        fi
14836        ac_sed_frag=`expr $ac_sed_frag + 1`
14837        ac_beg=$ac_end
# Line 8754 | Line 14849 | for ac_file in : $CONFIG_FILES; do test "x$ac_file" =
14849    # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
14850    case $ac_file in
14851    - | *:- | *:-:* ) # input from stdin
14852 <        cat >$tmp/stdin
14853 <        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
14854 <        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
14852 >        cat >$tmp/stdin
14853 >        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
14854 >        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
14855    *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
14856 <        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
14856 >        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
14857    * )   ac_file_in=$ac_file.in ;;
14858    esac
14859  
14860    # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
14861    ac_dir=`(dirname "$ac_file") 2>/dev/null ||
14862   $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
14863 <         X"$ac_file" : 'X\(//\)[^/]' \| \
14864 <         X"$ac_file" : 'X\(//\)$' \| \
14865 <         X"$ac_file" : 'X\(/\)' \| \
14866 <         .     : '\(.\)' 2>/dev/null ||
14863 >         X"$ac_file" : 'X\(//\)[^/]' \| \
14864 >         X"$ac_file" : 'X\(//\)$' \| \
14865 >         X"$ac_file" : 'X\(/\)' \| \
14866 >         .     : '\(.\)' 2>/dev/null ||
14867   echo X"$ac_file" |
14868      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
14869            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 8784 | Line 14879 | $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
14879        as_dirs="$as_dir $as_dirs"
14880        as_dir=`(dirname "$as_dir") 2>/dev/null ||
14881   $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
14882 <         X"$as_dir" : 'X\(//\)[^/]' \| \
14883 <         X"$as_dir" : 'X\(//\)$' \| \
14884 <         X"$as_dir" : 'X\(/\)' \| \
14885 <         .     : '\(.\)' 2>/dev/null ||
14882 >         X"$as_dir" : 'X\(//\)[^/]' \| \
14883 >         X"$as_dir" : 'X\(//\)$' \| \
14884 >         X"$as_dir" : 'X\(/\)' \| \
14885 >         .     : '\(.\)' 2>/dev/null ||
14886   echo X"$as_dir" |
14887      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
14888            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 8825 | Line 14920 | esac
14920      ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
14921      ac_top_srcdir=$ac_top_builddir$srcdir ;;
14922   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`
14923  
14924 + # Do not use `cd foo && pwd` to compute absolute paths, because
14925 + # the directories may not exist.
14926 + case `pwd` in
14927 + .) ac_abs_builddir="$ac_dir";;
14928 + *)
14929 +  case "$ac_dir" in
14930 +  .) ac_abs_builddir=`pwd`;;
14931 +  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
14932 +  *) ac_abs_builddir=`pwd`/"$ac_dir";;
14933 +  esac;;
14934 + esac
14935 + case $ac_abs_builddir in
14936 + .) ac_abs_top_builddir=${ac_top_builddir}.;;
14937 + *)
14938 +  case ${ac_top_builddir}. in
14939 +  .) ac_abs_top_builddir=$ac_abs_builddir;;
14940 +  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
14941 +  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
14942 +  esac;;
14943 + esac
14944 + case $ac_abs_builddir in
14945 + .) ac_abs_srcdir=$ac_srcdir;;
14946 + *)
14947 +  case $ac_srcdir in
14948 +  .) ac_abs_srcdir=$ac_abs_builddir;;
14949 +  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
14950 +  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
14951 +  esac;;
14952 + esac
14953 + case $ac_abs_builddir in
14954 + .) ac_abs_top_srcdir=$ac_top_srcdir;;
14955 + *)
14956 +  case $ac_top_srcdir in
14957 +  .) ac_abs_top_srcdir=$ac_abs_builddir;;
14958 +  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
14959 +  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
14960 +  esac;;
14961 + esac
14962  
14963 +
14964    case $INSTALL in
14965    [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
14966    *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
# Line 8852 | Line 14980 | echo "$as_me: creating $ac_file" >&6;}
14980      configure_input="$ac_file.  "
14981    fi
14982    configure_input=$configure_input"Generated from `echo $ac_file_in |
14983 <                                     sed 's,.*/,,'` by configure."
14983 >                                     sed 's,.*/,,'` by configure."
14984  
14985    # First look for the input files in the build tree, otherwise in the
14986    # src tree.
# Line 8861 | Line 14989 | echo "$as_me: creating $ac_file" >&6;}
14989        case $f in
14990        -) echo $tmp/stdin ;;
14991        [\\/$]*)
14992 <         # Absolute (can't be DOS-style, as IFS=:)
14993 <         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
14992 >         # Absolute (can't be DOS-style, as IFS=:)
14993 >         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
14994   echo "$as_me: error: cannot find input file: $f" >&2;}
14995     { (exit 1); exit 1; }; }
14996 <         echo $f;;
14996 >         echo "$f";;
14997        *) # Relative
14998 <         if test -f "$f"; then
14999 <           # Build tree
15000 <           echo $f
15001 <         elif test -f "$srcdir/$f"; then
15002 <           # Source tree
15003 <           echo $srcdir/$f
15004 <         else
15005 <           # /dev/null tree
15006 <           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
14998 >         if test -f "$f"; then
14999 >           # Build tree
15000 >           echo "$f"
15001 >         elif test -f "$srcdir/$f"; then
15002 >           # Source tree
15003 >           echo "$srcdir/$f"
15004 >         else
15005 >           # /dev/null tree
15006 >           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15007   echo "$as_me: error: cannot find input file: $f" >&2;}
15008     { (exit 1); exit 1; }; }
15009 <         fi;;
15009 >         fi;;
15010        esac
15011      done` || { (exit 1); exit 1; }
15012   _ACEOF
# Line 8908 | Line 15036 | s,@INSTALL@,$ac_INSTALL,;t t
15036      rm -f $tmp/out
15037    fi
15038  
15039 +  # Run the commands associated with the file.
15040 +  case $ac_file in
15041 +    make/Makefile ) chmod 0755 scripts/* ;;
15042 +    src/utils/Makefile ) chmod 0755 scripts/* ;;
15043 +    src/applications/nanoRodBuilder/Makefile ) chmod 0755 scripts/* ;;
15044 +    scripts/filepp ) chmod 0755 scripts/* ;;
15045 +  esac
15046   done
15047   _ACEOF
15048   cat >>$CONFIG_STATUS <<\_ACEOF
# Line 8920 | Line 15055 | cat >>$CONFIG_STATUS <<\_ACEOF
15055   # NAME is the cpp macro being defined and VALUE is the value it is being given.
15056   #
15057   # ac_d sets the value in "#define NAME VALUE" lines.
15058 < ac_dA='s,^\([   ]*\)#\([        ]*define[       ][      ]*\)'
15059 < ac_dB='[        ].*$,\1#\2'
15058 > ac_dA='s,^\([    ]*\)#\([        ]*define[       ][      ]*\)'
15059 > ac_dB='[         ].*$,\1#\2'
15060   ac_dC=' '
15061   ac_dD=',;t'
15062   # ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
15063 < ac_uA='s,^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
15063 > ac_uA='s,^\([    ]*\)#\([        ]*\)undef\([    ][      ]*\)'
15064   ac_uB='$,\1#\2define\3'
15065   ac_uC=' '
15066   ac_uD=',;t'
# Line 8934 | Line 15069 | for ac_file in : $CONFIG_HEADERS; do test "x$ac_file"
15069    # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
15070    case $ac_file in
15071    - | *:- | *:-:* ) # input from stdin
15072 <        cat >$tmp/stdin
15073 <        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15074 <        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15072 >        cat >$tmp/stdin
15073 >        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15074 >        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15075    *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15076 <        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15076 >        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15077    * )   ac_file_in=$ac_file.in ;;
15078    esac
15079  
# Line 8952 | Line 15087 | echo "$as_me: creating $ac_file" >&6;}
15087        case $f in
15088        -) echo $tmp/stdin ;;
15089        [\\/$]*)
15090 <         # Absolute (can't be DOS-style, as IFS=:)
15091 <         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15090 >         # Absolute (can't be DOS-style, as IFS=:)
15091 >         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15092   echo "$as_me: error: cannot find input file: $f" >&2;}
15093     { (exit 1); exit 1; }; }
15094 <         echo $f;;
15094 >         # Do quote $f, to prevent DOS paths from being IFS'd.
15095 >         echo "$f";;
15096        *) # Relative
15097 <         if test -f "$f"; then
15098 <           # Build tree
15099 <           echo $f
15100 <         elif test -f "$srcdir/$f"; then
15101 <           # Source tree
15102 <           echo $srcdir/$f
15103 <         else
15104 <           # /dev/null tree
15105 <           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15097 >         if test -f "$f"; then
15098 >           # Build tree
15099 >           echo "$f"
15100 >         elif test -f "$srcdir/$f"; then
15101 >           # Source tree
15102 >           echo "$srcdir/$f"
15103 >         else
15104 >           # /dev/null tree
15105 >           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15106   echo "$as_me: error: cannot find input file: $f" >&2;}
15107     { (exit 1); exit 1; }; }
15108 <         fi;;
15108 >         fi;;
15109        esac
15110      done` || { (exit 1); exit 1; }
15111    # Remove the trailing spaces.
15112 <  sed 's/[      ]*$//' $ac_file_inputs >$tmp/in
15112 >  sed 's/[       ]*$//' $ac_file_inputs >$tmp/in
15113  
15114   _ACEOF
15115  
# Line 8996 | Line 15132 | t clear
15132   s,[\\$`],\\&,g
15133   t clear
15134   : clear
15135 < s,^[    ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
15135 > s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
15136   t end
15137 < s,^[    ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
15137 > s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
15138   : end
15139   _ACEOF
15140   # If some macros were called several times there might be several times
# Line 9012 | Line 15148 | cat >>conftest.undefs <<\_ACEOF
15148   # example, in the case of _POSIX_SOURCE, which is predefined and required
15149   # on some systems where configure will not decide to define it.
15150   cat >>conftest.undefs <<\_ACEOF
15151 < s,^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
15151 > s,^[     ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
15152   _ACEOF
15153  
15154   # Break up conftest.defines because some shells have a limit on the size
15155   # of here documents, and old seds have small limits too (100 cmds).
15156   echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
15157 < echo '  if grep "^[     ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
15157 > echo '  if grep "^[      ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
15158   echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
15159   echo '  :' >>$CONFIG_STATUS
15160   rm -f conftest.tail
# Line 9027 | Line 15163 | do
15163    # Write a limited-size here document to $tmp/defines.sed.
15164    echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
15165    # Speed up: don't consider the non `#define' lines.
15166 <  echo '/^[     ]*#[    ]*define/!b' >>$CONFIG_STATUS
15166 >  echo '/^[      ]*#[    ]*define/!b' >>$CONFIG_STATUS
15167    # Work around the forget-to-reset-the-flag bug.
15168    echo 't clr' >>$CONFIG_STATUS
15169    echo ': clr' >>$CONFIG_STATUS
# Line 9054 | Line 15190 | do
15190    # Write a limited-size here document to $tmp/undefs.sed.
15191    echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
15192    # Speed up: don't consider the non `#undef'
15193 <  echo '/^[     ]*#[    ]*undef/!b' >>$CONFIG_STATUS
15193 >  echo '/^[      ]*#[    ]*undef/!b' >>$CONFIG_STATUS
15194    # Work around the forget-to-reset-the-flag bug.
15195    echo 't clr' >>$CONFIG_STATUS
15196    echo ': clr' >>$CONFIG_STATUS
# Line 9088 | Line 15224 | $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
15224      else
15225        ac_dir=`(dirname "$ac_file") 2>/dev/null ||
15226   $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15227 <         X"$ac_file" : 'X\(//\)[^/]' \| \
15228 <         X"$ac_file" : 'X\(//\)$' \| \
15229 <         X"$ac_file" : 'X\(/\)' \| \
15230 <         .     : '\(.\)' 2>/dev/null ||
15227 >         X"$ac_file" : 'X\(//\)[^/]' \| \
15228 >         X"$ac_file" : 'X\(//\)$' \| \
15229 >         X"$ac_file" : 'X\(/\)' \| \
15230 >         .     : '\(.\)' 2>/dev/null ||
15231   echo X"$ac_file" |
15232      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15233            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 9107 | Line 15243 | $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
15243        as_dirs="$as_dir $as_dirs"
15244        as_dir=`(dirname "$as_dir") 2>/dev/null ||
15245   $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15246 <         X"$as_dir" : 'X\(//\)[^/]' \| \
15247 <         X"$as_dir" : 'X\(//\)$' \| \
15248 <         X"$as_dir" : 'X\(/\)' \| \
15249 <         .     : '\(.\)' 2>/dev/null ||
15246 >         X"$as_dir" : 'X\(//\)[^/]' \| \
15247 >         X"$as_dir" : 'X\(//\)$' \| \
15248 >         X"$as_dir" : 'X\(/\)' \| \
15249 >         .     : '\(.\)' 2>/dev/null ||
15250   echo X"$as_dir" |
15251      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15252            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 9155 | Line 15291 | $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
15291    # Make relative symlinks.
15292    ac_dest_dir=`(dirname "$ac_dest") 2>/dev/null ||
15293   $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15294 <         X"$ac_dest" : 'X\(//\)[^/]' \| \
15295 <         X"$ac_dest" : 'X\(//\)$' \| \
15296 <         X"$ac_dest" : 'X\(/\)' \| \
15297 <         .     : '\(.\)' 2>/dev/null ||
15294 >         X"$ac_dest" : 'X\(//\)[^/]' \| \
15295 >         X"$ac_dest" : 'X\(//\)$' \| \
15296 >         X"$ac_dest" : 'X\(/\)' \| \
15297 >         .     : '\(.\)' 2>/dev/null ||
15298   echo X"$ac_dest" |
15299      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15300            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 9174 | Line 15310 | $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
15310        as_dirs="$as_dir $as_dirs"
15311        as_dir=`(dirname "$as_dir") 2>/dev/null ||
15312   $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15313 <         X"$as_dir" : 'X\(//\)[^/]' \| \
15314 <         X"$as_dir" : 'X\(//\)$' \| \
15315 <         X"$as_dir" : 'X\(/\)' \| \
15316 <         .     : '\(.\)' 2>/dev/null ||
15313 >         X"$as_dir" : 'X\(//\)[^/]' \| \
15314 >         X"$as_dir" : 'X\(//\)$' \| \
15315 >         X"$as_dir" : 'X\(/\)' \| \
15316 >         .     : '\(.\)' 2>/dev/null ||
15317   echo X"$as_dir" |
15318      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15319            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 9215 | Line 15351 | esac
15351      ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
15352      ac_top_srcdir=$ac_top_builddir$srcdir ;;
15353   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`
15354  
15355 + # Do not use `cd foo && pwd` to compute absolute paths, because
15356 + # the directories may not exist.
15357 + case `pwd` in
15358 + .) ac_abs_builddir="$ac_dest_dir";;
15359 + *)
15360 +  case "$ac_dest_dir" in
15361 +  .) ac_abs_builddir=`pwd`;;
15362 +  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dest_dir";;
15363 +  *) ac_abs_builddir=`pwd`/"$ac_dest_dir";;
15364 +  esac;;
15365 + esac
15366 + case $ac_abs_builddir in
15367 + .) ac_abs_top_builddir=${ac_top_builddir}.;;
15368 + *)
15369 +  case ${ac_top_builddir}. in
15370 +  .) ac_abs_top_builddir=$ac_abs_builddir;;
15371 +  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
15372 +  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
15373 +  esac;;
15374 + esac
15375 + case $ac_abs_builddir in
15376 + .) ac_abs_srcdir=$ac_srcdir;;
15377 + *)
15378 +  case $ac_srcdir in
15379 +  .) ac_abs_srcdir=$ac_abs_builddir;;
15380 +  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
15381 +  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
15382 +  esac;;
15383 + esac
15384 + case $ac_abs_builddir in
15385 + .) ac_abs_top_srcdir=$ac_top_srcdir;;
15386 + *)
15387 +  case $ac_top_srcdir in
15388 +  .) ac_abs_top_srcdir=$ac_abs_builddir;;
15389 +  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
15390 +  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
15391 +  esac;;
15392 + esac
15393  
15394 +
15395    case $srcdir in
15396    [\\/$]* | ?:[\\/]* ) ac_rel_source=$srcdir/$ac_source ;;
15397        *) ac_rel_source=$ac_top_builddir$srcdir/$ac_source ;;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines