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 1206 by chuckv, Sat Dec 8 00:15:09 2007 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 4.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='4.0'
273 > PACKAGE_STRING='OOPSE 4.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 USE_SINGLE_PRECISION 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 QHULL_INC_DIR QHULL_LIB_DIR QHULL USE_QHULL LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI CGAL_CXXFLAGS CGAL_LDFLAGS CGAL_CPPFLAGS CGAL_LIBS USE_CGAL 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 4.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 4.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-qhull=DIR        root directory path of qhull installation (defaults
891 +                          to /usr/local or /usr if not found in /usr/local)
892    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
893 <  --with-sprng=<prefix>   compile with SPRNG installed in <prefix>
894 <                          [default=/usr/local]
880 <  --with-mkl              Do we want MKL will check /usr/local/intel/mkl61 /opt/intel/mkl61
893 >  --with-cgalmakefile=makefile
894 >                          Use the following CGAL makefile
895  
896   Some influential environment variables:
897 <  CC          C compiler command
898 <  CFLAGS      C compiler flags
897 >  CXX         C++ compiler command
898 >  CXXFLAGS    C++ compiler flags
899    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
900                nonstandard directory <lib dir>
901    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
902                headers in a nonstandard directory <include dir>
903 <  CXX         C++ compiler command
904 <  CXXFLAGS    C++ compiler flags
905 <  F90         Fortran 90 compiler command
906 <  F90FLAGS    Fortran 90 compiler flags
903 >  CC          C compiler command
904 >  CFLAGS      C compiler flags
905 >  FC          Fortran compiler command
906 >  FCFLAGS     Fortran compiler flags
907    CPP         C preprocessor
908 +  CXXCPP      C++ preprocessor
909  
910   Use these variables to override the choices made by `configure' or to help
911   it to find libraries and programs with nonstandard names/locations.
# Line 929 | Line 944 | esac
944      ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
945      ac_top_srcdir=$ac_top_builddir$srcdir ;;
946   esac
947 < # Don't blindly perform a `cd "$ac_dir"/$ac_foo && pwd` since $ac_foo can be
948 < # absolute.
949 < ac_abs_builddir=`cd "$ac_dir" && cd $ac_builddir && pwd`
950 < ac_abs_top_builddir=`cd "$ac_dir" && cd ${ac_top_builddir}. && pwd`
951 < ac_abs_srcdir=`cd "$ac_dir" && cd $ac_srcdir && pwd`
952 < ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir && pwd`
947 >
948 > # Do not use `cd foo && pwd` to compute absolute paths, because
949 > # the directories may not exist.
950 > case `pwd` in
951 > .) ac_abs_builddir="$ac_dir";;
952 > *)
953 >  case "$ac_dir" in
954 >  .) ac_abs_builddir=`pwd`;;
955 >  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
956 >  *) ac_abs_builddir=`pwd`/"$ac_dir";;
957 >  esac;;
958 > esac
959 > case $ac_abs_builddir in
960 > .) ac_abs_top_builddir=${ac_top_builddir}.;;
961 > *)
962 >  case ${ac_top_builddir}. in
963 >  .) ac_abs_top_builddir=$ac_abs_builddir;;
964 >  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
965 >  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
966 >  esac;;
967 > esac
968 > case $ac_abs_builddir in
969 > .) ac_abs_srcdir=$ac_srcdir;;
970 > *)
971 >  case $ac_srcdir in
972 >  .) ac_abs_srcdir=$ac_abs_builddir;;
973 >  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
974 >  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
975 >  esac;;
976 > esac
977 > case $ac_abs_builddir in
978 > .) ac_abs_top_srcdir=$ac_top_srcdir;;
979 > *)
980 >  case $ac_top_srcdir in
981 >  .) ac_abs_top_srcdir=$ac_abs_builddir;;
982 >  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
983 >  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
984 >  esac;;
985 > esac
986  
987      cd $ac_dir
988      # Check for guested configure; otherwise get Cygnus style configure.
# Line 945 | Line 993 | ac_abs_top_srcdir=`cd "$ac_dir" && cd $ac_top_srcdir &
993        echo
994        $SHELL $ac_srcdir/configure  --help=recursive
995      elif test -f $ac_srcdir/configure.ac ||
996 <           test -f $ac_srcdir/configure.in; then
996 >           test -f $ac_srcdir/configure.in; then
997        echo
998        $ac_configure --help
999      else
# Line 958 | Line 1006 | if $ac_init_version; then
1006   test -n "$ac_init_help" && exit 0
1007   if $ac_init_version; then
1008    cat <<\_ACEOF
1009 < OOPSE configure 2.0
1010 < generated by GNU Autoconf 2.57
1009 > OOPSE configure 4.0
1010 > generated by GNU Autoconf 2.59
1011  
1012 < Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002
965 < Free Software Foundation, Inc.
1012 > Copyright (C) 2003 Free Software Foundation, Inc.
1013   This configure script is free software; the Free Software Foundation
1014   gives unlimited permission to copy, distribute and modify it.
1015   _ACEOF
# Line 973 | Line 1020 | running configure, to aid debugging if configure makes
1020   This file contains any messages produced by compilers while
1021   running configure, to aid debugging if configure makes a mistake.
1022  
1023 < It was created by OOPSE $as_me 2.0, which was
1024 < generated by GNU Autoconf 2.57.  Invocation command line was
1023 > It was created by OOPSE $as_me 4.0, which was
1024 > generated by GNU Autoconf 2.59.  Invocation command line was
1025  
1026    $ $0 $@
1027  
# Line 1051 | Line 1098 | do
1098      2)
1099        ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1100        if test $ac_must_keep_next = true; then
1101 <        ac_must_keep_next=false # Got value, back to normal.
1101 >        ac_must_keep_next=false # Got value, back to normal.
1102        else
1103 <        case $ac_arg in
1104 <          *=* | --config-cache | -C | -disable-* | --disable-* \
1105 <          | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1106 <          | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1107 <          | -with-* | --with-* | -without-* | --without-* | --x)
1108 <            case "$ac_configure_args0 " in
1109 <              "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1110 <            esac
1111 <            ;;
1112 <          -* ) ac_must_keep_next=true ;;
1113 <        esac
1103 >        case $ac_arg in
1104 >          *=* | --config-cache | -C | -disable-* | --disable-* \
1105 >          | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1106 >          | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1107 >          | -with-* | --with-* | -without-* | --without-* | --x)
1108 >            case "$ac_configure_args0 " in
1109 >              "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1110 >            esac
1111 >            ;;
1112 >          -* ) ac_must_keep_next=true ;;
1113 >        esac
1114        fi
1115        ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1116        # Get rid of the leading space.
# Line 1097 | Line 1144 | _ASBOX
1144      case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1145      *ac_space=\ *)
1146        sed -n \
1147 <        "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1148 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1147 >        "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1148 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1149        ;;
1150      *)
1151        sed -n \
1152 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1152 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1153        ;;
1154      esac;
1155   }
# Line 1131 | Line 1178 | _ASBOX
1178        for ac_var in $ac_subst_files
1179        do
1180          eval ac_val=$`echo $ac_var`
1181 <        echo "$ac_var='"'"'$ac_val'"'"'"
1181 >        echo "$ac_var='"'"'$ac_val'"'"'"
1182        done | sort
1183        echo
1184      fi
# Line 1150 | Line 1197 | _ASBOX
1197        echo "$as_me: caught signal $ac_signal"
1198      echo "$as_me: exit $exit_status"
1199    } >&5
1200 <  rm -f core core.* *.core &&
1200 >  rm -f core *.core &&
1201    rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1202      exit $exit_status
1203       ' 0
# Line 1230 | Line 1277 | for ac_var in `(set) 2>&1 |
1277   # value.
1278   ac_cache_corrupted=false
1279   for ac_var in `(set) 2>&1 |
1280 <               sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1280 >               sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1281    eval ac_old_set=\$ac_cv_env_${ac_var}_set
1282    eval ac_new_set=\$ac_env_${ac_var}_set
1283    eval ac_old_val="\$ac_cv_env_${ac_var}_value"
# Line 1247 | Line 1294 | echo "$as_me: error: \`$ac_var' was not set in the pre
1294      ,);;
1295      *)
1296        if test "x$ac_old_val" != "x$ac_new_val"; then
1297 <        { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1297 >        { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1298   echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1299 <        { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1299 >        { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1300   echo "$as_me:   former value:  $ac_old_val" >&2;}
1301 <        { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1301 >        { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1302   echo "$as_me:   current value: $ac_new_val" >&2;}
1303 <        ac_cache_corrupted=:
1303 >        ac_cache_corrupted=:
1304        fi;;
1305    esac
1306    # Pass precious variables to config.status.
# Line 1335 | Line 1382 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1382   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1383  
1384  
1385 < # 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).
1385 >          ac_config_headers="$ac_config_headers src/config.h"
1386  
1387  
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
1388  
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
1389  
1390  
1391  
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
1392  
1393  
1394  
1458 ## ----------------------- ##
1459 ## 1. Language selection.  ##
1460 ## ----------------------- ##
1395  
1462 # ----------------------------- #
1463 # 1b. The Fortran 90 language.  #
1464 # ----------------------------- #
1396  
1466 # AC_LANG(Fortran 90)
1467 # -------------------
1397  
1398  
1399  
1471 # _AC_LANG_ABBREV(Fortran 90)
1472 # ---------------------------
1400  
1401  
1402  
1476 # ----------------------------- #
1477 # 1c. The Fortran 95 language.  #
1478 # ----------------------------- #
1403  
1480 # AC_LANG(Fortran 95)
1481 # -------------------
1404  
1405  
1406  
1485 # _AC_LANG_ABBREV(Fortran 95)
1486 # ---------------------------
1407  
1408  
1409  
1490 ## ---------------------- ##
1491 ## 2.Producing programs.  ##
1492 ## ---------------------- ##
1410  
1494 # ------------------------ #
1495 # 2b. Fortran 90 sources.  #
1496 # ------------------------ #
1411  
1498 # AC_LANG_SOURCE(Fortran 90)(BODY)
1499 # --------------------------------
1412  
1413  
1414  
1503 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1504 # -----------------------------------------------
1415  
1416  
1507 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1508 # --------------------------------------------
1417  
1418  
1419  
1512 # ------------------------ #
1513 # 2c. Fortran 95 sources.  #
1514 # ------------------------ #
1420  
1516 # AC_LANG_SOURCE(Fortran 95)(BODY)
1517 # --------------------------------
1421  
1422  
1520 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1521 # -----------------------------------------------
1423  
1424  
1524 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1525 # --------------------------------------------
1425  
1426  
1427  
1529 ## -------------------------------------------- ##
1530 ## 3. Looking for Compilers and Preprocessors.  ##
1531 ## -------------------------------------------- ##
1428  
1533 # ----------------------------- #
1534 # 3b. The Fortran 90 compiler.  #
1535 # ----------------------------- #
1429  
1430 + #
1431 + #
1432 + #
1433  
1538 # AC_LANG_PREPROC(Fortran 90)
1539 # ---------------------------
1540 # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1434  
1435  
1436  
1544 # AC_LANG_COMPILER(Fortran 90)
1545 # ----------------------------
1546 # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1547 # AC_REQUIRE'able.
1437  
1438  
1439  
1440 < # AC_PROG_F90([COMPILERS...])
1441 < # ---------------------------
1442 < # COMPILERS is a space separated list of Fortran 90 compilers to search
1554 < # for.
1440 >
1441 > # AC_F90_MODULE_NAMES
1442 > # -------------------
1443   #
1444 < # Compilers are ordered by
1557 < #  1. F90, F95
1558 < #  2. Good/tested native compilers, bad/untested native compilers
1444 > # Figure out how the Fortran 90 compiler constructs module file names
1445   #
1446 < # 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
1446 > # AC_F90_MODULE_NAMES
1447  
1448  
1568 # ----------------------------- #
1569 # 3c. The Fortran 95 compiler.  #
1570 # ----------------------------- #
1449  
1450  
1573 # AC_LANG_PREPROC(Fortran 95)
1574 # ---------------------------
1575 # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1451  
1452  
1453  
1579 # AC_LANG_COMPILER(Fortran 95)
1580 # ----------------------------
1581 # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1582 # AC_REQUIRE'able.
1454  
1455  
1456  
1586 # AC_PROG_F95([COMPILERS...])
1587 # ---------------------------
1588 # COMPILERS is a space separated list of Fortran 95 compilers to search
1589 # for.
1590 #
1591 # Compilers are ordered by
1592 #  1. Good/tested native compilers, bad/untested native compilers
1593 #
1594 # xlf95 is the IBM (AIX) F95 compiler.
1595 # lf95 is the Lahey-Fujitsu compiler.
1596 # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1597 # AC_PROG_F95
1457  
1458  
1600 ## ------------------------------- ##
1601 ## 4. Compilers' characteristics.  ##
1602 ## ------------------------------- ##
1459  
1460  
1605 # ---------------------------------------- #
1606 # 4b. Fortan 90 compiler characteristics.  #
1607 # ---------------------------------------- #
1461  
1462  
1610 # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1611 # -------------------------------------------------
1612 # Link a trivial Fortran program, compiling with a verbose output FLAG
1613 # (which default value, $ac_cv_prog_f90_v, is computed by
1614 # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1615 # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1616 # so that any link flags that are echoed by the compiler appear as
1617 # space-separated items.
1618 # _AC_PROG_F90_V_OUTPUT
1463  
1464  
1621 # _AC_PROG_F90_V
1622 # --------------
1623 #
1624 # Determine the flag that causes the Fortran 90 compiler to print
1625 # information of library and object files (normally -v)
1626 # Needed for AC_F90_LIBRARY_FLAGS
1627 # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1628 # _AC_PROG_F90_V
1465  
1466  
1631 # AC_F90_LIBRARY_LDFLAGS
1632 # ----------------------
1633 #
1634 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1635 # intrinsic and run-time libraries that are required to successfully
1636 # link a Fortran 90 program or shared library.  The output variable
1637 # F90LIBS is set to these flags.
1638 #
1639 # This macro is intended to be used in those situations when it is
1640 # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1641 # program or shared library.
1642 #
1643 # For example, if object files from a C++ and Fortran 90 compiler must
1644 # be linked together, then the C++ compiler/linker must be used for
1645 # linking (since special C++-ish things need to happen at link time
1646 # like calling global constructors, instantiating templates, enabling
1647 # exception support, etc.).
1648 #
1649 # However, the Fortran 90 intrinsic and run-time libraries must be
1650 # linked in as well, but the C++ compiler/linker doesn't know how to
1651 # add these Fortran 90 libraries.  Hence, the macro
1652 # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1653 # libraries.
1654 #
1655 # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1656 # AC_F90_LIBRARY_LDFLAGS
1467  
1468  
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
1469  
1676 # The replacement is empty.
1470  
1471  
1472  
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
1473  
1474  
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
1475  
1476  
1697 # ---------------------------------------- #
1698 # 4c. Fortan 95 compiler characteristics.  #
1699 # ---------------------------------------- #
1477  
1478  
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
1479  
1480  
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
1481  
1482  
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
1483  
1484  
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
1485  
1768 # The replacement is empty.
1486  
1487  
1488  
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
1489  
1490  
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
1491  
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
1492  
1493  
1494  
# Line 1850 | Line 1548 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1548  
1549  
1550  
1853 # set program name
1854 PROGNAME="oopse"
1551  
1552  
1857 # there are two ways to do debugging.  One with the --enable-debug flag
1858 # and one using the DEBUG environment variable
1553  
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
1554  
1868 cat >>confdefs.h <<\_ACEOF
1869 #define debug 1
1870 _ACEOF
1555  
1556 <  msg="$msg, debug mode"
1557 < fi
1556 > # This is taken from http://autoqt.sourceforge.net/
1557 > # Copyright (c) 2002, Geoffrey Wossum
1558 > # All rights reserved.
1559  
1560 + # Redistribution and use in source and binary forms, with or without
1561 + # modification, are permitted provided that the following conditions are
1562 + # met:
1563  
1564 + #  - Redistributions of source code must retain the above copyright notice,
1565 + #    this list of conditions and the following disclaimer.
1566 +
1567 + #  - Redistributions in binary form must reproduce the above copyright
1568 + #    notice, this list of conditions and the following disclaimer in the
1569 + #    documentation and/or other materials provided with the distribution.
1570 +
1571 + #  - Neither the name of Geoffrey Wossum nor the names of its
1572 + #    contributors may be used to endorse or promote products derived from
1573 + #    this software without specific prior written permission.
1574 +
1575 +
1576 + # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
1577 + # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
1578 + # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
1579 + # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
1580 + # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
1581 + # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
1582 + # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
1583 + # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
1584 + # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
1585 + # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
1586 + # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1587 +
1588 +
1589 + # Check for Qt compiler flags, linker flags, and binary packages
1590 +
1591 +
1592 +
1593   # who am i
1594   # Make sure we can run config.sub.
1595   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 1931 | Line 1648 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1648  
1649  
1650  
1651 < ac_ext=c
1652 < ac_cpp='$CPP $CPPFLAGS'
1653 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1654 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1655 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1651 > # set program name
1652 > PROGNAME="oopse"
1653 >
1654 >
1655 >
1656 >
1657 > OBJEXT=".$OBJEXT"
1658 >
1659 > OOPSE=oopse
1660 >
1661 > if test "x${prefix}" = "xNONE"
1662 > then
1663 >  OOPSE_HOME=${ac_default_prefix}/oopse
1664 > else
1665 >  OOPSE_HOME=${prefix}/oopse
1666 > fi
1667 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1668 > if test "${enable_oopse_home+set}" = set; then
1669 >  enableval="$enable_oopse_home"
1670 >  OOPSE_HOME="${enableval}"
1671 > fi;
1672 >
1673 > # there are two ways to do debugging.  One with the --enable-debug flag
1674 > # and one using the DEBUG environment variable
1675 >
1676 > debug=0
1677 > # Check whether --enable-debug or --disable-debug was given.
1678 > if test "${enable_debug+set}" = set; then
1679 >  enableval="$enable_debug"
1680 >  debug=1
1681 > fi;
1682 > if test "${DEBUG}"; then
1683 >
1684 > cat >>confdefs.h <<\_ACEOF
1685 > #define debug 1
1686 > _ACEOF
1687 >
1688 >  msg="$msg, debug mode"
1689 > fi
1690 >
1691 >
1692 > # Check whether --enable-single or --disable-single was given.
1693 > if test "${enable_single+set}" = set; then
1694 >  enableval="$enable_single"
1695 >  ok=$enableval
1696 > else
1697 >  ok=no
1698 > fi;
1699 > # Check whether --enable-float or --disable-float was given.
1700 > if test "${enable_float+set}" = set; then
1701 >  enableval="$enable_float"
1702 >  ok=$enableval
1703 > fi;
1704 > if test "$ok" = "yes"; then
1705 >
1706 > cat >>confdefs.h <<\_ACEOF
1707 > #define SINGLE_PRECISION 1
1708 > _ACEOF
1709 >
1710 >        USE_SINGLE_PRECISION=yes
1711 >
1712 > fi
1713 >
1714 > # Checks for programs.
1715 > ac_ext=cc
1716 > ac_cpp='$CXXCPP $CPPFLAGS'
1717 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1718 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1719 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1720   if test -n "$ac_tool_prefix"; then
1721 <  for ac_prog in icc xlc gcc cc
1721 >  for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1722    do
1723      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1724   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1725   echo "$as_me:$LINENO: checking for $ac_word" >&5
1726   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1727 < if test "${ac_cv_prog_CC+set}" = set; then
1727 > if test "${ac_cv_prog_CXX+set}" = set; then
1728    echo $ECHO_N "(cached) $ECHO_C" >&6
1729   else
1730 <  if test -n "$CC"; then
1731 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1730 >  if test -n "$CXX"; then
1731 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1732   else
1733   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1734   for as_dir in $PATH
# Line 1956 | Line 1737 | do
1737    test -z "$as_dir" && as_dir=.
1738    for ac_exec_ext in '' $ac_executable_extensions; do
1739    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1740 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1740 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1741      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1742      break 2
1743    fi
# Line 1965 | Line 1746 | fi
1746  
1747   fi
1748   fi
1749 < CC=$ac_cv_prog_CC
1750 < if test -n "$CC"; then
1751 <  echo "$as_me:$LINENO: result: $CC" >&5
1752 < echo "${ECHO_T}$CC" >&6
1749 > CXX=$ac_cv_prog_CXX
1750 > if test -n "$CXX"; then
1751 >  echo "$as_me:$LINENO: result: $CXX" >&5
1752 > echo "${ECHO_T}$CXX" >&6
1753   else
1754    echo "$as_me:$LINENO: result: no" >&5
1755   echo "${ECHO_T}no" >&6
1756   fi
1757  
1758 <    test -n "$CC" && break
1758 >    test -n "$CXX" && break
1759    done
1760   fi
1761 < if test -z "$CC"; then
1762 <  ac_ct_CC=$CC
1763 <  for ac_prog in icc xlc gcc cc
1761 > if test -z "$CXX"; then
1762 >  ac_ct_CXX=$CXX
1763 >  for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1764   do
1765    # Extract the first word of "$ac_prog", so it can be a program name with args.
1766   set dummy $ac_prog; ac_word=$2
1767   echo "$as_me:$LINENO: checking for $ac_word" >&5
1768   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1769 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1769 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1770    echo $ECHO_N "(cached) $ECHO_C" >&6
1771   else
1772 <  if test -n "$ac_ct_CC"; then
1773 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1772 >  if test -n "$ac_ct_CXX"; then
1773 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1774   else
1775   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1776   for as_dir in $PATH
# Line 1998 | Line 1779 | do
1779    test -z "$as_dir" && as_dir=.
1780    for ac_exec_ext in '' $ac_executable_extensions; do
1781    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1782 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1782 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1783      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1784      break 2
1785    fi
# Line 2007 | Line 1788 | fi
1788  
1789   fi
1790   fi
1791 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1792 < if test -n "$ac_ct_CC"; then
1793 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1794 < echo "${ECHO_T}$ac_ct_CC" >&6
1791 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1792 > if test -n "$ac_ct_CXX"; then
1793 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1794 > echo "${ECHO_T}$ac_ct_CXX" >&6
1795   else
1796    echo "$as_me:$LINENO: result: no" >&5
1797   echo "${ECHO_T}no" >&6
1798   fi
1799  
1800 <  test -n "$ac_ct_CC" && break
1800 >  test -n "$ac_ct_CXX" && break
1801   done
1802 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1803  
1804 <  CC=$ac_ct_CC
1804 >  CXX=$ac_ct_CXX
1805   fi
1806  
1807  
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
1808   # Provide some information about the compiler.
1809   echo "$as_me:$LINENO:" \
1810 <     "checking for C compiler version" >&5
1810 >     "checking for C++ compiler version" >&5
1811   ac_compiler=`set X $ac_compile; echo $2`
1812   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1813    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2050 | Line 1826 | cat >conftest.$ac_ext <<_ACEOF
1826    (exit $ac_status); }
1827  
1828   cat >conftest.$ac_ext <<_ACEOF
2053 #line $LINENO "configure"
1829   /* confdefs.h.  */
1830   _ACEOF
1831   cat confdefs.h >>conftest.$ac_ext
# Line 2070 | Line 1845 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1845   # Try to create an executable without -o first, disregard a.out.
1846   # It will help us diagnose broken compilers, and finding out an intuition
1847   # of exeext.
1848 < echo "$as_me:$LINENO: checking for C compiler default output" >&5
1849 < echo $ECHO_N "checking for C compiler default output... $ECHO_C" >&6
1848 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1849 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1850   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1851   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1852    (eval $ac_link_default) 2>&5
# Line 2091 | Line 1866 | do
1866    test -f "$ac_file" || continue
1867    case $ac_file in
1868      *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
1869 <        ;;
1869 >        ;;
1870      conftest.$ac_ext )
1871 <        # This is the source file.
1872 <        ;;
1871 >        # This is the source file.
1872 >        ;;
1873      [ab].out )
1874 <        # We found the default executable, but exeext='' is most
1875 <        # certainly right.
1876 <        break;;
1874 >        # We found the default executable, but exeext='' is most
1875 >        # certainly right.
1876 >        break;;
1877      *.* )
1878 <        ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
1879 <        # FIXME: I believe we export ac_cv_exeext for Libtool,
1880 <        # but it would be cool to find out if it's true.  Does anybody
1881 <        # maintain Libtool? --akim.
1882 <        export ac_cv_exeext
1883 <        break;;
1878 >        ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
1879 >        # FIXME: I believe we export ac_cv_exeext for Libtool,
1880 >        # but it would be cool to find out if it's true.  Does anybody
1881 >        # maintain Libtool? --akim.
1882 >        export ac_cv_exeext
1883 >        break;;
1884      * )
1885 <        break;;
1885 >        break;;
1886    esac
1887   done
1888   else
1889    echo "$as_me: failed program was:" >&5
1890   sed 's/^/| /' conftest.$ac_ext >&5
1891  
1892 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1892 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1893   See \`config.log' for more details." >&5
1894 < echo "$as_me: error: C compiler cannot create executables
1894 > echo "$as_me: error: C++ compiler cannot create executables
1895   See \`config.log' for more details." >&2;}
1896     { (exit 77); exit 77; }; }
1897   fi
# Line 2127 | Line 1902 | echo "${ECHO_T}$ac_file" >&6
1902  
1903   # Check the compiler produces executables we can run.  If not, either
1904   # the compiler is broken, or we cross compile.
1905 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1906 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1905 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1906 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1907   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1908   # If not cross compiling, check that we can run a simple program.
1909   if test "$cross_compiling" != yes; then
# Line 2143 | Line 1918 | if test "$cross_compiling" != yes; then
1918      if test "$cross_compiling" = maybe; then
1919          cross_compiling=yes
1920      else
1921 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1921 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1922   If you meant to cross compile, use \`--host'.
1923   See \`config.log' for more details." >&5
1924 < echo "$as_me: error: cannot run C compiled programs.
1924 > echo "$as_me: error: cannot run C++ compiled programs.
1925   If you meant to cross compile, use \`--host'.
1926   See \`config.log' for more details." >&2;}
1927     { (exit 1); exit 1; }; }
# Line 2181 | Line 1956 | for ac_file in conftest.exe conftest conftest.*; do
1956    case $ac_file in
1957      *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
1958      *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
1959 <          export ac_cv_exeext
1960 <          break;;
1959 >          export ac_cv_exeext
1960 >          break;;
1961      * ) break;;
1962    esac
1963   done
# Line 2207 | Line 1982 | else
1982    echo $ECHO_N "(cached) $ECHO_C" >&6
1983   else
1984    cat >conftest.$ac_ext <<_ACEOF
2210 #line $LINENO "configure"
1985   /* confdefs.h.  */
1986   _ACEOF
1987   cat confdefs.h >>conftest.$ac_ext
# Line 2252 | Line 2026 | ac_objext=$OBJEXT
2026   echo "${ECHO_T}$ac_cv_objext" >&6
2027   OBJEXT=$ac_cv_objext
2028   ac_objext=$OBJEXT
2029 < echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2030 < echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2031 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
2029 > echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2030 > echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2031 > if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2032    echo $ECHO_N "(cached) $ECHO_C" >&6
2033   else
2034    cat >conftest.$ac_ext <<_ACEOF
2261 #line $LINENO "configure"
2035   /* confdefs.h.  */
2036   _ACEOF
2037   cat confdefs.h >>conftest.$ac_ext
# Line 2278 | Line 2051 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2051   _ACEOF
2052   rm -f conftest.$ac_objext
2053   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2054 <  (eval $ac_compile) 2>&5
2054 >  (eval $ac_compile) 2>conftest.er1
2055    ac_status=$?
2056 +  grep -v '^ *+' conftest.er1 >conftest.err
2057 +  rm -f conftest.er1
2058 +  cat conftest.err >&5
2059    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2060    (exit $ac_status); } &&
2061 <         { ac_try='test -s conftest.$ac_objext'
2061 >         { ac_try='test -z "$ac_cxx_werror_flag"
2062 >                         || test ! -s conftest.err'
2063    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2064    (eval $ac_try) 2>&5
2065    ac_status=$?
2066    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2067 +  (exit $ac_status); }; } &&
2068 +         { ac_try='test -s conftest.$ac_objext'
2069 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2070 +  (eval $ac_try) 2>&5
2071 +  ac_status=$?
2072 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2073    (exit $ac_status); }; }; then
2074    ac_compiler_gnu=yes
2075   else
# Line 2295 | Line 2078 | fi
2078  
2079   ac_compiler_gnu=no
2080   fi
2081 < rm -f conftest.$ac_objext conftest.$ac_ext
2082 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
2081 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2082 > ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2083  
2084   fi
2085 < echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2086 < echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2087 < GCC=`test $ac_compiler_gnu = yes && echo yes`
2088 < ac_test_CFLAGS=${CFLAGS+set}
2089 < ac_save_CFLAGS=$CFLAGS
2090 < CFLAGS="-g"
2091 < echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2092 < echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2093 < if test "${ac_cv_prog_cc_g+set}" = set; then
2085 > echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2086 > echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2087 > GXX=`test $ac_compiler_gnu = yes && echo yes`
2088 > ac_test_CXXFLAGS=${CXXFLAGS+set}
2089 > ac_save_CXXFLAGS=$CXXFLAGS
2090 > CXXFLAGS="-g"
2091 > echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2092 > echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2093 > if test "${ac_cv_prog_cxx_g+set}" = set; then
2094    echo $ECHO_N "(cached) $ECHO_C" >&6
2095   else
2096    cat >conftest.$ac_ext <<_ACEOF
2314 #line $LINENO "configure"
2097   /* confdefs.h.  */
2098   _ACEOF
2099   cat confdefs.h >>conftest.$ac_ext
# Line 2328 | Line 2110 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2110   _ACEOF
2111   rm -f conftest.$ac_objext
2112   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2113 <  (eval $ac_compile) 2>&5
2113 >  (eval $ac_compile) 2>conftest.er1
2114    ac_status=$?
2115 +  grep -v '^ *+' conftest.er1 >conftest.err
2116 +  rm -f conftest.er1
2117 +  cat conftest.err >&5
2118    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2119    (exit $ac_status); } &&
2120 <         { ac_try='test -s conftest.$ac_objext'
2120 >         { ac_try='test -z "$ac_cxx_werror_flag"
2121 >                         || test ! -s conftest.err'
2122    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2123    (eval $ac_try) 2>&5
2124    ac_status=$?
2125    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2126 +  (exit $ac_status); }; } &&
2127 +         { ac_try='test -s conftest.$ac_objext'
2128 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2129 +  (eval $ac_try) 2>&5
2130 +  ac_status=$?
2131 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2132    (exit $ac_status); }; }; then
2133 <  ac_cv_prog_cc_g=yes
2133 >  ac_cv_prog_cxx_g=yes
2134   else
2135    echo "$as_me: failed program was:" >&5
2136   sed 's/^/| /' conftest.$ac_ext >&5
2137  
2138 < ac_cv_prog_cc_g=no
2138 > ac_cv_prog_cxx_g=no
2139   fi
2140 < rm -f conftest.$ac_objext conftest.$ac_ext
2140 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2141   fi
2142 < echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2143 < echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2144 < if test "$ac_test_CFLAGS" = set; then
2145 <  CFLAGS=$ac_save_CFLAGS
2146 < elif test $ac_cv_prog_cc_g = yes; then
2147 <  if test "$GCC" = yes; then
2148 <    CFLAGS="-g -O2"
2142 > echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2143 > echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2144 > if test "$ac_test_CXXFLAGS" = set; then
2145 >  CXXFLAGS=$ac_save_CXXFLAGS
2146 > elif test $ac_cv_prog_cxx_g = yes; then
2147 >  if test "$GXX" = yes; then
2148 >    CXXFLAGS="-g -O2"
2149    else
2150 <    CFLAGS="-g"
2150 >    CXXFLAGS="-g"
2151    fi
2152   else
2153 <  if test "$GCC" = yes; then
2154 <    CFLAGS="-O2"
2153 >  if test "$GXX" = yes; then
2154 >    CXXFLAGS="-O2"
2155    else
2156 <    CFLAGS=
2156 >    CXXFLAGS=
2157    fi
2158   fi
2159 < echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2160 < echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2161 < if test "${ac_cv_prog_cc_stdc+set}" = set; then
2162 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2163 < else
2164 <  ac_cv_prog_cc_stdc=no
2165 < ac_save_CC=$CC
2166 < cat >conftest.$ac_ext <<_ACEOF
2167 < #line $LINENO "configure"
2159 > for ac_declaration in \
2160 >   '' \
2161 >   'extern "C" void std::exit (int) throw (); using std::exit;' \
2162 >   'extern "C" void std::exit (int); using std::exit;' \
2163 >   'extern "C" void exit (int) throw ();' \
2164 >   'extern "C" void exit (int);' \
2165 >   'void exit (int);'
2166 > do
2167 >  cat >conftest.$ac_ext <<_ACEOF
2168   /* confdefs.h.  */
2169   _ACEOF
2170   cat confdefs.h >>conftest.$ac_ext
2171   cat >>conftest.$ac_ext <<_ACEOF
2172   /* end confdefs.h.  */
2173 < #include <stdarg.h>
2174 < #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;
2173 > $ac_declaration
2174 > #include <stdlib.h>
2175   int
2176   main ()
2177   {
2178 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2178 > exit (42);
2179    ;
2180    return 0;
2181   }
2182   _ACEOF
2183 < # 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
2183 > rm -f conftest.$ac_objext
2184   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2185 <  (eval $ac_compile) 2>&5
2185 >  (eval $ac_compile) 2>conftest.er1
2186    ac_status=$?
2187 +  grep -v '^ *+' conftest.er1 >conftest.err
2188 +  rm -f conftest.er1
2189 +  cat conftest.err >&5
2190    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2191    (exit $ac_status); } &&
2192 <         { ac_try='test -s conftest.$ac_objext'
2192 >         { ac_try='test -z "$ac_cxx_werror_flag"
2193 >                         || test ! -s conftest.err'
2194    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2195    (eval $ac_try) 2>&5
2196    ac_status=$?
2197    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2198 +  (exit $ac_status); }; } &&
2199 +         { ac_try='test -s conftest.$ac_objext'
2200 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2201 +  (eval $ac_try) 2>&5
2202 +  ac_status=$?
2203 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2204    (exit $ac_status); }; }; then
2205 <  ac_cv_prog_cc_stdc=$ac_arg
2440 < break
2205 >  :
2206   else
2207    echo "$as_me: failed program was:" >&5
2208   sed 's/^/| /' conftest.$ac_ext >&5
2209  
2210 + continue
2211   fi
2212 < rm -f conftest.$ac_objext
2213 < done
2214 < 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
2212 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2213 >  cat >conftest.$ac_ext <<_ACEOF
2214 > /* confdefs.h.  */
2215   _ACEOF
2216 + cat confdefs.h >>conftest.$ac_ext
2217 + cat >>conftest.$ac_ext <<_ACEOF
2218 + /* end confdefs.h.  */
2219 + $ac_declaration
2220 + int
2221 + main ()
2222 + {
2223 + exit (42);
2224 +  ;
2225 +  return 0;
2226 + }
2227 + _ACEOF
2228   rm -f conftest.$ac_objext
2229   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2230 <  (eval $ac_compile) 2>&5
2230 >  (eval $ac_compile) 2>conftest.er1
2231    ac_status=$?
2232 +  grep -v '^ *+' conftest.er1 >conftest.err
2233 +  rm -f conftest.er1
2234 +  cat conftest.err >&5
2235    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2236    (exit $ac_status); } &&
2237 <         { ac_try='test -s conftest.$ac_objext'
2237 >         { ac_try='test -z "$ac_cxx_werror_flag"
2238 >                         || test ! -s conftest.err'
2239    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2240    (eval $ac_try) 2>&5
2241    ac_status=$?
2242    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2243 <  (exit $ac_status); }; }; then
2244 <  for ac_declaration in \
2485 <   ''\
2486 <   '#include <stdlib.h>' \
2487 <   'extern "C" void std::exit (int) throw (); using std::exit;' \
2488 <   'extern "C" void std::exit (int); using std::exit;' \
2489 <   'extern "C" void exit (int) throw ();' \
2490 <   'extern "C" void exit (int);' \
2491 <   'void exit (int);'
2492 < do
2493 <  cat >conftest.$ac_ext <<_ACEOF
2494 < #line $LINENO "configure"
2495 < /* confdefs.h.  */
2496 < _ACEOF
2497 < cat confdefs.h >>conftest.$ac_ext
2498 < cat >>conftest.$ac_ext <<_ACEOF
2499 < /* end confdefs.h.  */
2500 < #include <stdlib.h>
2501 < $ac_declaration
2502 < int
2503 < main ()
2504 < {
2505 < exit (42);
2506 <  ;
2507 <  return 0;
2508 < }
2509 < _ACEOF
2510 < rm -f conftest.$ac_objext
2511 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2512 <  (eval $ac_compile) 2>&5
2513 <  ac_status=$?
2514 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2515 <  (exit $ac_status); } &&
2516 <         { ac_try='test -s conftest.$ac_objext'
2243 >  (exit $ac_status); }; } &&
2244 >         { ac_try='test -s conftest.$ac_objext'
2245    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2246    (eval $ac_try) 2>&5
2247    ac_status=$?
2248    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2249    (exit $ac_status); }; }; then
2522  :
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'
2553  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2554  (eval $ac_try) 2>&5
2555  ac_status=$?
2556  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2557  (exit $ac_status); }; }; then
2250    break
2251   else
2252    echo "$as_me: failed program was:" >&5
2253   sed 's/^/| /' conftest.$ac_ext >&5
2254  
2255   fi
2256 < rm -f conftest.$ac_objext conftest.$ac_ext
2256 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2257   done
2258   rm -f conftest*
2259   if test -n "$ac_declaration"; then
# Line 2570 | Line 2262 | fi
2262    echo '#endif'             >>confdefs.h
2263   fi
2264  
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
2265   ac_ext=c
2266   ac_cpp='$CPP $CPPFLAGS'
2267   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2268   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2269   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2270  
2271 <
2272 < ac_ext=cc
2273 < ac_cpp='$CXXCPP $CPPFLAGS'
2274 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2275 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2590 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2271 > ac_ext=c
2272 > ac_cpp='$CPP $CPPFLAGS'
2273 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2274 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2275 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2276   if test -n "$ac_tool_prefix"; then
2277 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2277 >  for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2278    do
2279      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2280   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2281   echo "$as_me:$LINENO: checking for $ac_word" >&5
2282   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2283 < if test "${ac_cv_prog_CXX+set}" = set; then
2283 > if test "${ac_cv_prog_CC+set}" = set; then
2284    echo $ECHO_N "(cached) $ECHO_C" >&6
2285   else
2286 <  if test -n "$CXX"; then
2287 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2286 >  if test -n "$CC"; then
2287 >  ac_cv_prog_CC="$CC" # Let the user override the test.
2288   else
2289   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2290   for as_dir in $PATH
# Line 2608 | Line 2293 | do
2293    test -z "$as_dir" && as_dir=.
2294    for ac_exec_ext in '' $ac_executable_extensions; do
2295    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2296 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2296 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2297      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2298      break 2
2299    fi
# Line 2617 | Line 2302 | fi
2302  
2303   fi
2304   fi
2305 < CXX=$ac_cv_prog_CXX
2306 < if test -n "$CXX"; then
2307 <  echo "$as_me:$LINENO: result: $CXX" >&5
2308 < echo "${ECHO_T}$CXX" >&6
2305 > CC=$ac_cv_prog_CC
2306 > if test -n "$CC"; then
2307 >  echo "$as_me:$LINENO: result: $CC" >&5
2308 > echo "${ECHO_T}$CC" >&6
2309   else
2310    echo "$as_me:$LINENO: result: no" >&5
2311   echo "${ECHO_T}no" >&6
2312   fi
2313  
2314 <    test -n "$CXX" && break
2314 >    test -n "$CC" && break
2315    done
2316   fi
2317 < if test -z "$CXX"; then
2318 <  ac_ct_CXX=$CXX
2319 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2317 > if test -z "$CC"; then
2318 >  ac_ct_CC=$CC
2319 >  for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2320   do
2321    # Extract the first word of "$ac_prog", so it can be a program name with args.
2322   set dummy $ac_prog; ac_word=$2
2323   echo "$as_me:$LINENO: checking for $ac_word" >&5
2324   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2325 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2325 > if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2326    echo $ECHO_N "(cached) $ECHO_C" >&6
2327   else
2328 <  if test -n "$ac_ct_CXX"; then
2329 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2328 >  if test -n "$ac_ct_CC"; then
2329 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2330   else
2331   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2332   for as_dir in $PATH
# Line 2650 | Line 2335 | do
2335    test -z "$as_dir" && as_dir=.
2336    for ac_exec_ext in '' $ac_executable_extensions; do
2337    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2338 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2338 >    ac_cv_prog_ac_ct_CC="$ac_prog"
2339      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2340      break 2
2341    fi
# Line 2659 | Line 2344 | fi
2344  
2345   fi
2346   fi
2347 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2348 < if test -n "$ac_ct_CXX"; then
2349 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2350 < echo "${ECHO_T}$ac_ct_CXX" >&6
2347 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
2348 > if test -n "$ac_ct_CC"; then
2349 >  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2350 > echo "${ECHO_T}$ac_ct_CC" >&6
2351   else
2352    echo "$as_me:$LINENO: result: no" >&5
2353   echo "${ECHO_T}no" >&6
2354   fi
2355  
2356 <  test -n "$ac_ct_CXX" && break
2357 < done
2673 < test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2356 >  test -n "$ac_ct_CC" && break
2357 > done
2358  
2359 <  CXX=$ac_ct_CXX
2359 >  CC=$ac_ct_CC
2360   fi
2361  
2362  
2363 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2364 + See \`config.log' for more details." >&5
2365 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2366 + See \`config.log' for more details." >&2;}
2367 +   { (exit 1); exit 1; }; }
2368 +
2369   # Provide some information about the compiler.
2370   echo "$as_me:$LINENO:" \
2371 <     "checking for C++ compiler version" >&5
2371 >     "checking for C compiler version" >&5
2372   ac_compiler=`set X $ac_compile; echo $2`
2373   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2374    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2696 | Line 2386 | ac_compiler=`set X $ac_compile; echo $2`
2386    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2387    (exit $ac_status); }
2388  
2389 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2390 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2391 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2389 > echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2390 > echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2391 > if test "${ac_cv_c_compiler_gnu+set}" = set; then
2392    echo $ECHO_N "(cached) $ECHO_C" >&6
2393   else
2394    cat >conftest.$ac_ext <<_ACEOF
2705 #line $LINENO "configure"
2395   /* confdefs.h.  */
2396   _ACEOF
2397   cat confdefs.h >>conftest.$ac_ext
# Line 2722 | Line 2411 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2411   _ACEOF
2412   rm -f conftest.$ac_objext
2413   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2414 <  (eval $ac_compile) 2>&5
2414 >  (eval $ac_compile) 2>conftest.er1
2415    ac_status=$?
2416 +  grep -v '^ *+' conftest.er1 >conftest.err
2417 +  rm -f conftest.er1
2418 +  cat conftest.err >&5
2419    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2420    (exit $ac_status); } &&
2421 <         { ac_try='test -s conftest.$ac_objext'
2421 >         { ac_try='test -z "$ac_c_werror_flag"
2422 >                         || test ! -s conftest.err'
2423    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2424    (eval $ac_try) 2>&5
2425    ac_status=$?
2426    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2427 +  (exit $ac_status); }; } &&
2428 +         { ac_try='test -s conftest.$ac_objext'
2429 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2430 +  (eval $ac_try) 2>&5
2431 +  ac_status=$?
2432 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2433    (exit $ac_status); }; }; then
2434    ac_compiler_gnu=yes
2435   else
# Line 2739 | Line 2438 | fi
2438  
2439   ac_compiler_gnu=no
2440   fi
2441 < rm -f conftest.$ac_objext conftest.$ac_ext
2442 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2441 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2442 > ac_cv_c_compiler_gnu=$ac_compiler_gnu
2443  
2444   fi
2445 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2446 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2447 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2448 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2449 < ac_save_CXXFLAGS=$CXXFLAGS
2450 < CXXFLAGS="-g"
2451 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2452 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2453 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2445 > echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2446 > echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2447 > GCC=`test $ac_compiler_gnu = yes && echo yes`
2448 > ac_test_CFLAGS=${CFLAGS+set}
2449 > ac_save_CFLAGS=$CFLAGS
2450 > CFLAGS="-g"
2451 > echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2452 > echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2453 > if test "${ac_cv_prog_cc_g+set}" = set; then
2454    echo $ECHO_N "(cached) $ECHO_C" >&6
2455   else
2456    cat >conftest.$ac_ext <<_ACEOF
2758 #line $LINENO "configure"
2457   /* confdefs.h.  */
2458   _ACEOF
2459   cat confdefs.h >>conftest.$ac_ext
# Line 2772 | Line 2470 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2470   _ACEOF
2471   rm -f conftest.$ac_objext
2472   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2473 <  (eval $ac_compile) 2>&5
2473 >  (eval $ac_compile) 2>conftest.er1
2474    ac_status=$?
2475 +  grep -v '^ *+' conftest.er1 >conftest.err
2476 +  rm -f conftest.er1
2477 +  cat conftest.err >&5
2478    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2479    (exit $ac_status); } &&
2480 <         { ac_try='test -s conftest.$ac_objext'
2480 >         { ac_try='test -z "$ac_c_werror_flag"
2481 >                         || test ! -s conftest.err'
2482    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2483    (eval $ac_try) 2>&5
2484    ac_status=$?
2485    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2486 +  (exit $ac_status); }; } &&
2487 +         { ac_try='test -s conftest.$ac_objext'
2488 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2489 +  (eval $ac_try) 2>&5
2490 +  ac_status=$?
2491 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2492    (exit $ac_status); }; }; then
2493 <  ac_cv_prog_cxx_g=yes
2493 >  ac_cv_prog_cc_g=yes
2494   else
2495    echo "$as_me: failed program was:" >&5
2496   sed 's/^/| /' conftest.$ac_ext >&5
2497  
2498 < ac_cv_prog_cxx_g=no
2498 > ac_cv_prog_cc_g=no
2499   fi
2500 < rm -f conftest.$ac_objext conftest.$ac_ext
2500 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2501   fi
2502 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2503 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2504 < if test "$ac_test_CXXFLAGS" = set; then
2505 <  CXXFLAGS=$ac_save_CXXFLAGS
2506 < elif test $ac_cv_prog_cxx_g = yes; then
2507 <  if test "$GXX" = yes; then
2508 <    CXXFLAGS="-g -O2"
2502 > echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2503 > echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2504 > if test "$ac_test_CFLAGS" = set; then
2505 >  CFLAGS=$ac_save_CFLAGS
2506 > elif test $ac_cv_prog_cc_g = yes; then
2507 >  if test "$GCC" = yes; then
2508 >    CFLAGS="-g -O2"
2509    else
2510 <    CXXFLAGS="-g"
2510 >    CFLAGS="-g"
2511    fi
2512   else
2513 <  if test "$GXX" = yes; then
2514 <    CXXFLAGS="-O2"
2513 >  if test "$GCC" = yes; then
2514 >    CFLAGS="-O2"
2515    else
2516 <    CXXFLAGS=
2516 >    CFLAGS=
2517    fi
2518   fi
2519 < for ac_declaration in \
2520 <   ''\
2521 <   '#include <stdlib.h>' \
2519 > echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2520 > echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2521 > if test "${ac_cv_prog_cc_stdc+set}" = set; then
2522 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2523 > else
2524 >  ac_cv_prog_cc_stdc=no
2525 > ac_save_CC=$CC
2526 > cat >conftest.$ac_ext <<_ACEOF
2527 > /* confdefs.h.  */
2528 > _ACEOF
2529 > cat confdefs.h >>conftest.$ac_ext
2530 > cat >>conftest.$ac_ext <<_ACEOF
2531 > /* end confdefs.h.  */
2532 > #include <stdarg.h>
2533 > #include <stdio.h>
2534 > #include <sys/types.h>
2535 > #include <sys/stat.h>
2536 > /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2537 > struct buf { int x; };
2538 > FILE * (*rcsopen) (struct buf *, struct stat *, int);
2539 > static char *e (p, i)
2540 >     char **p;
2541 >     int i;
2542 > {
2543 >  return p[i];
2544 > }
2545 > static char *f (char * (*g) (char **, int), char **p, ...)
2546 > {
2547 >  char *s;
2548 >  va_list v;
2549 >  va_start (v,p);
2550 >  s = g (p, va_arg (v,int));
2551 >  va_end (v);
2552 >  return s;
2553 > }
2554 >
2555 > /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2556 >   function prototypes and stuff, but not '\xHH' hex character constants.
2557 >   These don't provoke an error unfortunately, instead are silently treated
2558 >   as 'x'.  The following induces an error, until -std1 is added to get
2559 >   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2560 >   array size at least.  It's necessary to write '\x00'==0 to get something
2561 >   that's true only with -std1.  */
2562 > int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2563 >
2564 > int test (int i, double x);
2565 > struct s1 {int (*f) (int a);};
2566 > struct s2 {int (*f) (double a);};
2567 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2568 > int argc;
2569 > char **argv;
2570 > int
2571 > main ()
2572 > {
2573 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2574 >  ;
2575 >  return 0;
2576 > }
2577 > _ACEOF
2578 > # Don't try gcc -ansi; that turns off useful extensions and
2579 > # breaks some systems' header files.
2580 > # AIX                   -qlanglvl=ansi
2581 > # Ultrix and OSF/1      -std1
2582 > # HP-UX 10.20 and later -Ae
2583 > # HP-UX older versions  -Aa -D_HPUX_SOURCE
2584 > # SVR4                  -Xc -D__EXTENSIONS__
2585 > for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2586 > do
2587 >  CC="$ac_save_CC $ac_arg"
2588 >  rm -f conftest.$ac_objext
2589 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2590 >  (eval $ac_compile) 2>conftest.er1
2591 >  ac_status=$?
2592 >  grep -v '^ *+' conftest.er1 >conftest.err
2593 >  rm -f conftest.er1
2594 >  cat conftest.err >&5
2595 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2596 >  (exit $ac_status); } &&
2597 >         { ac_try='test -z "$ac_c_werror_flag"
2598 >                         || test ! -s conftest.err'
2599 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2600 >  (eval $ac_try) 2>&5
2601 >  ac_status=$?
2602 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2603 >  (exit $ac_status); }; } &&
2604 >         { ac_try='test -s conftest.$ac_objext'
2605 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2606 >  (eval $ac_try) 2>&5
2607 >  ac_status=$?
2608 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2609 >  (exit $ac_status); }; }; then
2610 >  ac_cv_prog_cc_stdc=$ac_arg
2611 > break
2612 > else
2613 >  echo "$as_me: failed program was:" >&5
2614 > sed 's/^/| /' conftest.$ac_ext >&5
2615 >
2616 > fi
2617 > rm -f conftest.err conftest.$ac_objext
2618 > done
2619 > rm -f conftest.$ac_ext conftest.$ac_objext
2620 > CC=$ac_save_CC
2621 >
2622 > fi
2623 >
2624 > case "x$ac_cv_prog_cc_stdc" in
2625 >  x|xno)
2626 >    echo "$as_me:$LINENO: result: none needed" >&5
2627 > echo "${ECHO_T}none needed" >&6 ;;
2628 >  *)
2629 >    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2630 > echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2631 >    CC="$CC $ac_cv_prog_cc_stdc" ;;
2632 > esac
2633 >
2634 > # Some people use a C++ compiler to compile C.  Since we use `exit',
2635 > # in C++ we need to declare it.  In case someone uses the same compiler
2636 > # for both compiling C and C++ we need to have the C++ compiler decide
2637 > # the declaration of exit, since it's the most demanding environment.
2638 > cat >conftest.$ac_ext <<_ACEOF
2639 > #ifndef __cplusplus
2640 >  choke me
2641 > #endif
2642 > _ACEOF
2643 > rm -f conftest.$ac_objext
2644 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2645 >  (eval $ac_compile) 2>conftest.er1
2646 >  ac_status=$?
2647 >  grep -v '^ *+' conftest.er1 >conftest.err
2648 >  rm -f conftest.er1
2649 >  cat conftest.err >&5
2650 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2651 >  (exit $ac_status); } &&
2652 >         { ac_try='test -z "$ac_c_werror_flag"
2653 >                         || test ! -s conftest.err'
2654 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2655 >  (eval $ac_try) 2>&5
2656 >  ac_status=$?
2657 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2658 >  (exit $ac_status); }; } &&
2659 >         { ac_try='test -s conftest.$ac_objext'
2660 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2661 >  (eval $ac_try) 2>&5
2662 >  ac_status=$?
2663 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2664 >  (exit $ac_status); }; }; then
2665 >  for ac_declaration in \
2666 >   '' \
2667     'extern "C" void std::exit (int) throw (); using std::exit;' \
2668     'extern "C" void std::exit (int); using std::exit;' \
2669     'extern "C" void exit (int) throw ();' \
# Line 2818 | Line 2671 | do
2671     'void exit (int);'
2672   do
2673    cat >conftest.$ac_ext <<_ACEOF
2821 #line $LINENO "configure"
2674   /* confdefs.h.  */
2675   _ACEOF
2676   cat confdefs.h >>conftest.$ac_ext
2677   cat >>conftest.$ac_ext <<_ACEOF
2678   /* end confdefs.h.  */
2827 #include <stdlib.h>
2679   $ac_declaration
2680 + #include <stdlib.h>
2681   int
2682   main ()
2683   {
# Line 2836 | Line 2688 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2688   _ACEOF
2689   rm -f conftest.$ac_objext
2690   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2691 <  (eval $ac_compile) 2>&5
2691 >  (eval $ac_compile) 2>conftest.er1
2692    ac_status=$?
2693 +  grep -v '^ *+' conftest.er1 >conftest.err
2694 +  rm -f conftest.er1
2695 +  cat conftest.err >&5
2696    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2697    (exit $ac_status); } &&
2698 <         { ac_try='test -s conftest.$ac_objext'
2698 >         { ac_try='test -z "$ac_c_werror_flag"
2699 >                         || test ! -s conftest.err'
2700    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2701    (eval $ac_try) 2>&5
2702    ac_status=$?
2703    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2704 +  (exit $ac_status); }; } &&
2705 +         { ac_try='test -s conftest.$ac_objext'
2706 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2707 +  (eval $ac_try) 2>&5
2708 +  ac_status=$?
2709 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2710    (exit $ac_status); }; }; then
2711    :
2712   else
# Line 2853 | Line 2715 | fi
2715  
2716   continue
2717   fi
2718 < rm -f conftest.$ac_objext conftest.$ac_ext
2718 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2719    cat >conftest.$ac_ext <<_ACEOF
2858 #line $LINENO "configure"
2720   /* confdefs.h.  */
2721   _ACEOF
2722   cat confdefs.h >>conftest.$ac_ext
# Line 2872 | Line 2733 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2733   _ACEOF
2734   rm -f conftest.$ac_objext
2735   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2736 <  (eval $ac_compile) 2>&5
2736 >  (eval $ac_compile) 2>conftest.er1
2737    ac_status=$?
2738 +  grep -v '^ *+' conftest.er1 >conftest.err
2739 +  rm -f conftest.er1
2740 +  cat conftest.err >&5
2741    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2742    (exit $ac_status); } &&
2743 <         { ac_try='test -s conftest.$ac_objext'
2743 >         { ac_try='test -z "$ac_c_werror_flag"
2744 >                         || test ! -s conftest.err'
2745    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2746    (eval $ac_try) 2>&5
2747    ac_status=$?
2748    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2749 +  (exit $ac_status); }; } &&
2750 +         { ac_try='test -s conftest.$ac_objext'
2751 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2752 +  (eval $ac_try) 2>&5
2753 +  ac_status=$?
2754 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2755    (exit $ac_status); }; }; then
2756    break
2757   else
# Line 2888 | Line 2759 | fi
2759   sed 's/^/| /' conftest.$ac_ext >&5
2760  
2761   fi
2762 < rm -f conftest.$ac_objext conftest.$ac_ext
2762 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2763   done
2764   rm -f conftest*
2765   if test -n "$ac_declaration"; then
# Line 2897 | Line 2768 | fi
2768    echo '#endif'             >>confdefs.h
2769   fi
2770  
2771 + else
2772 +  echo "$as_me: failed program was:" >&5
2773 + sed 's/^/| /' conftest.$ac_ext >&5
2774 +
2775 + fi
2776 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2777   ac_ext=c
2778   ac_cpp='$CPP $CPPFLAGS'
2779   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2780   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2781   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2782  
2783 <
2784 < OOPSE_TEMPLATE_FLAGS=""
2785 < if test $ac_cv_cxx_compiler_gnu = no; then
2786 <  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
2783 > ac_ext=${FC_SRCEXT-f}
2784 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2785 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2786 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2787   if test -n "$ac_tool_prefix"; then
2788 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2788 >  for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2789    do
2790      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2791   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2792   echo "$as_me:$LINENO: checking for $ac_word" >&5
2793   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2794 < if test "${ac_cv_prog_F90+set}" = set; then
2794 > if test "${ac_cv_prog_FC+set}" = set; then
2795    echo $ECHO_N "(cached) $ECHO_C" >&6
2796   else
2797 <  if test -n "$F90"; then
2798 <  ac_cv_prog_F90="$F90" # Let the user override the test.
2797 >  if test -n "$FC"; then
2798 >  ac_cv_prog_FC="$FC" # Let the user override the test.
2799   else
2800   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2801   for as_dir in $PATH
# Line 2984 | Line 2804 | do
2804    test -z "$as_dir" && as_dir=.
2805    for ac_exec_ext in '' $ac_executable_extensions; do
2806    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2807 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
2807 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2808      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2809      break 2
2810    fi
# Line 2993 | Line 2813 | fi
2813  
2814   fi
2815   fi
2816 < F90=$ac_cv_prog_F90
2817 < if test -n "$F90"; then
2818 <  echo "$as_me:$LINENO: result: $F90" >&5
2819 < echo "${ECHO_T}$F90" >&6
2816 > FC=$ac_cv_prog_FC
2817 > if test -n "$FC"; then
2818 >  echo "$as_me:$LINENO: result: $FC" >&5
2819 > echo "${ECHO_T}$FC" >&6
2820   else
2821    echo "$as_me:$LINENO: result: no" >&5
2822   echo "${ECHO_T}no" >&6
2823   fi
2824  
2825 <    test -n "$F90" && break
2825 >    test -n "$FC" && break
2826    done
2827   fi
2828 < if test -z "$F90"; then
2829 <  ac_ct_F90=$F90
2830 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2828 > if test -z "$FC"; then
2829 >  ac_ct_FC=$FC
2830 >  for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2831   do
2832    # Extract the first word of "$ac_prog", so it can be a program name with args.
2833   set dummy $ac_prog; ac_word=$2
2834   echo "$as_me:$LINENO: checking for $ac_word" >&5
2835   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2836 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
2836 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2837    echo $ECHO_N "(cached) $ECHO_C" >&6
2838   else
2839 <  if test -n "$ac_ct_F90"; then
2840 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
2839 >  if test -n "$ac_ct_FC"; then
2840 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2841   else
2842   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2843   for as_dir in $PATH
# Line 3026 | Line 2846 | do
2846    test -z "$as_dir" && as_dir=.
2847    for ac_exec_ext in '' $ac_executable_extensions; do
2848    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2849 <    ac_cv_prog_ac_ct_F90="$ac_prog"
2849 >    ac_cv_prog_ac_ct_FC="$ac_prog"
2850      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2851      break 2
2852    fi
# Line 3035 | Line 2855 | fi
2855  
2856   fi
2857   fi
2858 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
2859 < if test -n "$ac_ct_F90"; then
2860 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
2861 < echo "${ECHO_T}$ac_ct_F90" >&6
2858 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
2859 > if test -n "$ac_ct_FC"; then
2860 >  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2861 > echo "${ECHO_T}$ac_ct_FC" >&6
2862   else
2863    echo "$as_me:$LINENO: result: no" >&5
2864   echo "${ECHO_T}no" >&6
2865   fi
2866  
2867 <  test -n "$ac_ct_F90" && break
2867 >  test -n "$ac_ct_FC" && break
2868   done
2869  
2870 <  F90=$ac_ct_F90
2870 >  FC=$ac_ct_FC
2871   fi
2872  
2873  
2874 < # If we don't use `.F90' as extension, the preprocessor is not run on the
2875 < # input file.
2874 > # Provide some information about the compiler.
2875 > echo "$as_me:2875:" \
2876 >     "checking for Fortran compiler version" >&5
2877 > ac_compiler=`set X $ac_compile; echo $2`
2878 > { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2879 >  (eval $ac_compiler --version </dev/null >&5) 2>&5
2880 >  ac_status=$?
2881 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2882 >  (exit $ac_status); }
2883 > { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2884 >  (eval $ac_compiler -v </dev/null >&5) 2>&5
2885 >  ac_status=$?
2886 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2887 >  (exit $ac_status); }
2888 > { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2889 >  (eval $ac_compiler -V </dev/null >&5) 2>&5
2890 >  ac_status=$?
2891 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2892 >  (exit $ac_status); }
2893 > rm -f a.out
2894 >
2895 > # If we don't use `.F' as extension, the preprocessor is not run on the
2896 > # input file.  (Note that this only needs to work for GNU compilers.)
2897   ac_save_ext=$ac_ext
2898 < ac_ext=F90
2899 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
2900 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
2901 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
2898 > ac_ext=F
2899 > echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2900 > echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2901 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2902    echo $ECHO_N "(cached) $ECHO_C" >&6
2903   else
2904    cat >conftest.$ac_ext <<_ACEOF
2905 <
3065 < program main
3066 <
2905 >      program main
2906   #ifndef __GNUC__
2907         choke me
2908   #endif
2909  
2910 < end program main
3072 <
2910 >      end
2911   _ACEOF
2912   rm -f conftest.$ac_objext
2913   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2914 <  (eval $ac_compile) 2>&5
2914 >  (eval $ac_compile) 2>conftest.er1
2915    ac_status=$?
2916 +  grep -v '^ *+' conftest.er1 >conftest.err
2917 +  rm -f conftest.er1
2918 +  cat conftest.err >&5
2919    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2920    (exit $ac_status); } &&
2921 <         { ac_try='test -s conftest.$ac_objext'
2921 >         { ac_try='test -z "$ac_fc_werror_flag"
2922 >                         || test ! -s conftest.err'
2923    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2924    (eval $ac_try) 2>&5
2925    ac_status=$?
2926    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2927 +  (exit $ac_status); }; } &&
2928 +         { ac_try='test -s conftest.$ac_objext'
2929 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2930 +  (eval $ac_try) 2>&5
2931 +  ac_status=$?
2932 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2933    (exit $ac_status); }; }; then
2934    ac_compiler_gnu=yes
2935   else
# Line 3090 | Line 2938 | fi
2938  
2939   ac_compiler_gnu=no
2940   fi
2941 < rm -f conftest.$ac_objext conftest.$ac_ext
2942 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
2941 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2942 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2943  
2944   fi
2945 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
2946 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
2945 > echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2946 > echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2947   ac_ext=$ac_save_ext
2948 < G95=`test $ac_compiler_gnu = yes && echo yes`
2949 < ac_ext=c
2950 < ac_cpp='$CPP $CPPFLAGS'
2951 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2952 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2953 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
2948 > ac_test_FFLAGS=${FCFLAGS+set}
2949 > ac_save_FFLAGS=$FCFLAGS
2950 > FCFLAGS=
2951 > echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2952 > echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2953 > if test "${ac_cv_prog_fc_g+set}" = set; then
2954 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2955 > else
2956 >  FCFLAGS=-g
2957 > cat >conftest.$ac_ext <<_ACEOF
2958 >      program main
2959  
2960 <
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 <
2960 >      end
2961   _ACEOF
2962   rm -f conftest.$ac_objext
2963   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2964 <  (eval $ac_compile) 2>&5
2964 >  (eval $ac_compile) 2>conftest.er1
2965    ac_status=$?
2966 +  grep -v '^ *+' conftest.er1 >conftest.err
2967 +  rm -f conftest.er1
2968 +  cat conftest.err >&5
2969    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2970    (exit $ac_status); } &&
2971 <         { ac_try='test -s conftest.$ac_objext'
2971 >         { ac_try='test -z "$ac_fc_werror_flag"
2972 >                         || test ! -s conftest.err'
2973    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2974    (eval $ac_try) 2>&5
2975    ac_status=$?
2976    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2977 +  (exit $ac_status); }; } &&
2978 +         { ac_try='test -s conftest.$ac_objext'
2979 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2980 +  (eval $ac_try) 2>&5
2981 +  ac_status=$?
2982 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2983    (exit $ac_status); }; }; then
2984 <  prepflagworks=1
2984 >  ac_cv_prog_fc_g=yes
2985   else
2986    echo "$as_me: failed program was:" >&5
2987   sed 's/^/| /' conftest.$ac_ext >&5
2988  
2989 < prepflagworks=0
2989 > ac_cv_prog_fc_g=no
2990   fi
2991 < rm -f conftest.$ac_objext conftest.$ac_ext
2991 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2992  
2993 <  F90FLAGS=$ac_save_F90FLAGS
2994 <  ac_ext=$ac_save_ext
2995 <  ac_ext=c
2993 > fi
2994 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2995 > echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2996 > if test "$ac_test_FFLAGS" = set; then
2997 >  FCFLAGS=$ac_save_FFLAGS
2998 > elif test $ac_cv_prog_fc_g = yes; then
2999 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
3000 >    FCFLAGS="-g -O2"
3001 >  else
3002 >    FCFLAGS="-g"
3003 >  fi
3004 > else
3005 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
3006 >    FCFLAGS="-O2"
3007 >  else
3008 >    FCFLAGS=
3009 >  fi
3010 > fi
3011 >
3012 > ac_ext=c
3013   ac_cpp='$CPP $CPPFLAGS'
3014   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3015   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3016   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3017  
3018 + ac_ext=c
3019 + ac_cpp='$CPP $CPPFLAGS'
3020 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3021 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3022 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
3023 + echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
3024 + echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
3025 + # On Suns, sometimes $CPP names a directory.
3026 + if test -n "$CPP" && test -d "$CPP"; then
3027 +  CPP=
3028 + fi
3029 + if test -z "$CPP"; then
3030 +  if test "${ac_cv_prog_CPP+set}" = set; then
3031 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3032 + else
3033 +      # Double quotes because CPP needs to be expanded
3034 +    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
3035 +    do
3036 +      ac_preproc_ok=false
3037 + for ac_c_preproc_warn_flag in '' yes
3038 + do
3039 +  # Use a header file that comes with gcc, so configuring glibc
3040 +  # with a fresh cross-compiler works.
3041 +  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3042 +  # <limits.h> exists even on freestanding compilers.
3043 +  # On the NeXT, cc -E runs the code through the compiler's parser,
3044 +  # not just through cpp. "Syntax error" is here to catch this case.
3045 +  cat >conftest.$ac_ext <<_ACEOF
3046 + /* confdefs.h.  */
3047 + _ACEOF
3048 + cat confdefs.h >>conftest.$ac_ext
3049 + cat >>conftest.$ac_ext <<_ACEOF
3050 + /* end confdefs.h.  */
3051 + #ifdef __STDC__
3052 + # include <limits.h>
3053 + #else
3054 + # include <assert.h>
3055 + #endif
3056 +                     Syntax error
3057 + _ACEOF
3058 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3059 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3060 +  ac_status=$?
3061 +  grep -v '^ *+' conftest.er1 >conftest.err
3062 +  rm -f conftest.er1
3063 +  cat conftest.err >&5
3064 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3065 +  (exit $ac_status); } >/dev/null; then
3066 +  if test -s conftest.err; then
3067 +    ac_cpp_err=$ac_c_preproc_warn_flag
3068 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3069 +  else
3070 +    ac_cpp_err=
3071 +  fi
3072 + else
3073 +  ac_cpp_err=yes
3074 + fi
3075 + if test -z "$ac_cpp_err"; then
3076 +  :
3077 + else
3078 +  echo "$as_me: failed program was:" >&5
3079 + sed 's/^/| /' conftest.$ac_ext >&5
3080  
3081 <  if test "$prepflagworks" = 1; then
3082 <    echo "$as_me:$LINENO: result: yes" >&5
3083 < echo "${ECHO_T}yes" >&6
3081 >  # Broken: fails on valid input.
3082 > continue
3083 > fi
3084 > rm -f conftest.err conftest.$ac_ext
3085  
3086 +  # OK, works on sane cases.  Now check whether non-existent headers
3087 +  # can be detected and how.
3088 +  cat >conftest.$ac_ext <<_ACEOF
3089 + /* confdefs.h.  */
3090 + _ACEOF
3091 + cat confdefs.h >>conftest.$ac_ext
3092 + cat >>conftest.$ac_ext <<_ACEOF
3093 + /* end confdefs.h.  */
3094 + #include <ac_nonexistent.h>
3095 + _ACEOF
3096 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3097 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3098 +  ac_status=$?
3099 +  grep -v '^ *+' conftest.er1 >conftest.err
3100 +  rm -f conftest.er1
3101 +  cat conftest.err >&5
3102 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3103 +  (exit $ac_status); } >/dev/null; then
3104 +  if test -s conftest.err; then
3105 +    ac_cpp_err=$ac_c_preproc_warn_flag
3106 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3107    else
3108 <    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; }; }
3108 >    ac_cpp_err=
3109    fi
3110 + else
3111 +  ac_cpp_err=yes
3112   fi
3113 + if test -z "$ac_cpp_err"; then
3114 +  # Broken: success on invalid input.
3115 + continue
3116 + else
3117 +  echo "$as_me: failed program was:" >&5
3118 + sed 's/^/| /' conftest.$ac_ext >&5
3119  
3120 +  # Passes both tests.
3121 + ac_preproc_ok=:
3122 + break
3123 + fi
3124 + rm -f conftest.err conftest.$ac_ext
3125  
3126 <
3127 <
3128 <
3129 < # Try to determine native compiler flags that allow us to use F90 suffix
3130 < # 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"
3126 > done
3127 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3128 > rm -f conftest.err conftest.$ac_ext
3129 > if $ac_preproc_ok; then
3130 >  break
3131   fi
3132  
3133 <    cat >conftest.$ac_ext <<_ACEOF
3133 >    done
3134 >    ac_cv_prog_CPP=$CPP
3135  
3136 <
3137 < program main
3138 <
3139 <  integer :: i
3140 < #ifdef TEST
3141 <  i = 1
3136 > fi
3137 >  CPP=$ac_cv_prog_CPP
3138 > else
3139 >  ac_cv_prog_CPP=$CPP
3140 > fi
3141 > echo "$as_me:$LINENO: result: $CPP" >&5
3142 > echo "${ECHO_T}$CPP" >&6
3143 > ac_preproc_ok=false
3144 > for ac_c_preproc_warn_flag in '' yes
3145 > do
3146 >  # Use a header file that comes with gcc, so configuring glibc
3147 >  # with a fresh cross-compiler works.
3148 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3149 >  # <limits.h> exists even on freestanding compilers.
3150 >  # On the NeXT, cc -E runs the code through the compiler's parser,
3151 >  # not just through cpp. "Syntax error" is here to catch this case.
3152 >  cat >conftest.$ac_ext <<_ACEOF
3153 > /* confdefs.h.  */
3154 > _ACEOF
3155 > cat confdefs.h >>conftest.$ac_ext
3156 > cat >>conftest.$ac_ext <<_ACEOF
3157 > /* end confdefs.h.  */
3158 > #ifdef __STDC__
3159 > # include <limits.h>
3160   #else
3161 <  choke me
3161 > # include <assert.h>
3162   #endif
3163 +                     Syntax error
3164 + _ACEOF
3165 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3166 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3167 +  ac_status=$?
3168 +  grep -v '^ *+' conftest.er1 >conftest.err
3169 +  rm -f conftest.er1
3170 +  cat conftest.err >&5
3171 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3172 +  (exit $ac_status); } >/dev/null; then
3173 +  if test -s conftest.err; then
3174 +    ac_cpp_err=$ac_c_preproc_warn_flag
3175 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3176 +  else
3177 +    ac_cpp_err=
3178 +  fi
3179 + else
3180 +  ac_cpp_err=yes
3181 + fi
3182 + if test -z "$ac_cpp_err"; then
3183 +  :
3184 + else
3185 +  echo "$as_me: failed program was:" >&5
3186 + sed 's/^/| /' conftest.$ac_ext >&5
3187  
3188 +  # Broken: fails on valid input.
3189 + continue
3190 + fi
3191 + rm -f conftest.err conftest.$ac_ext
3192  
3193 < end program main
3194 <
3193 >  # OK, works on sane cases.  Now check whether non-existent headers
3194 >  # can be detected and how.
3195 >  cat >conftest.$ac_ext <<_ACEOF
3196 > /* confdefs.h.  */
3197   _ACEOF
3198 < rm -f conftest.$ac_objext
3199 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3200 <  (eval $ac_compile) 2>&5
3198 > cat confdefs.h >>conftest.$ac_ext
3199 > cat >>conftest.$ac_ext <<_ACEOF
3200 > /* end confdefs.h.  */
3201 > #include <ac_nonexistent.h>
3202 > _ACEOF
3203 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3204 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3205    ac_status=$?
3206 +  grep -v '^ *+' conftest.er1 >conftest.err
3207 +  rm -f conftest.er1
3208 +  cat conftest.err >&5
3209    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3210 <  (exit $ac_status); } &&
3211 <         { ac_try='test -s conftest.$ac_objext'
3212 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3213 <  (eval $ac_try) 2>&5
3214 <  ac_status=$?
3215 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3216 <  (exit $ac_status); }; }; then
3282 <  prepdefflagworks=1
3210 >  (exit $ac_status); } >/dev/null; then
3211 >  if test -s conftest.err; then
3212 >    ac_cpp_err=$ac_c_preproc_warn_flag
3213 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3214 >  else
3215 >    ac_cpp_err=
3216 >  fi
3217   else
3218 +  ac_cpp_err=yes
3219 + fi
3220 + if test -z "$ac_cpp_err"; then
3221 +  # Broken: success on invalid input.
3222 + continue
3223 + else
3224    echo "$as_me: failed program was:" >&5
3225   sed 's/^/| /' conftest.$ac_ext >&5
3226  
3227 < prepdefflagworks=0
3227 >  # Passes both tests.
3228 > ac_preproc_ok=:
3229 > break
3230   fi
3231 < rm -f conftest.$ac_objext conftest.$ac_ext
3231 > rm -f conftest.err conftest.$ac_ext
3232  
3233 <  F90FLAGS=$ac_save_F90FLAGS
3234 <  ac_ext=$ac_save_ext
3235 <  ac_ext=c
3233 > done
3234 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3235 > rm -f conftest.err conftest.$ac_ext
3236 > if $ac_preproc_ok; then
3237 >  :
3238 > else
3239 >  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3240 > See \`config.log' for more details." >&5
3241 > echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3242 > See \`config.log' for more details." >&2;}
3243 >   { (exit 1); exit 1; }; }
3244 > fi
3245 >
3246 > ac_ext=c
3247   ac_cpp='$CPP $CPPFLAGS'
3248   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3249   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3250   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3251  
3252 + echo "$as_me:$LINENO: checking for egrep" >&5
3253 + echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3254 + if test "${ac_cv_prog_egrep+set}" = set; then
3255 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3256 + else
3257 +  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3258 +    then ac_cv_prog_egrep='grep -E'
3259 +    else ac_cv_prog_egrep='egrep'
3260 +    fi
3261 + fi
3262 + echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3263 + echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3264 + EGREP=$ac_cv_prog_egrep
3265  
3266  
3267 <  if test "$prepdefflagworks" = 1; then
3268 <    echo "$as_me:$LINENO: result: yes" >&5
3267 > echo "$as_me:$LINENO: checking whether ln -s works" >&5
3268 > echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3269 > LN_S=$as_ln_s
3270 > if test "$LN_S" = "ln -s"; then
3271 >  echo "$as_me:$LINENO: result: yes" >&5
3272   echo "${ECHO_T}yes" >&6
3273 <
3274 <  else
3275 <    echo "$as_me:$LINENO: result: no" >&5
3273 > else
3274 >  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3275 > echo "${ECHO_T}no, using $LN_S" >&6
3276 > fi
3277 >
3278 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3279 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3280 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3281 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3282 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3283 > else
3284 >  cat >conftest.make <<\_ACEOF
3285 > all:
3286 >        @echo 'ac_maketemp="$(MAKE)"'
3287 > _ACEOF
3288 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3289 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3290 > if test -n "$ac_maketemp"; then
3291 >  eval ac_cv_prog_make_${ac_make}_set=yes
3292 > else
3293 >  eval ac_cv_prog_make_${ac_make}_set=no
3294 > fi
3295 > rm -f conftest.make
3296 > fi
3297 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3298 >  echo "$as_me:$LINENO: result: yes" >&5
3299 > echo "${ECHO_T}yes" >&6
3300 >  SET_MAKE=
3301 > else
3302 >  echo "$as_me:$LINENO: result: no" >&5
3303   echo "${ECHO_T}no" >&6
3304 <    { { 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
3304 >  SET_MAKE="MAKE=${MAKE-make}"
3305   fi
3306  
3307 < ac_ext=f90
3308 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3309 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3310 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3307 > if test -n "$ac_tool_prefix"; then
3308 >  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3309 > set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3310 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3311 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3312 > if test "${ac_cv_prog_RANLIB+set}" = set; then
3313 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3314 > else
3315 >  if test -n "$RANLIB"; then
3316 >  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3317 > else
3318 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3319 > for as_dir in $PATH
3320 > do
3321 >  IFS=$as_save_IFS
3322 >  test -z "$as_dir" && as_dir=.
3323 >  for ac_exec_ext in '' $ac_executable_extensions; do
3324 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3325 >    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3326 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3327 >    break 2
3328 >  fi
3329 > done
3330 > done
3331  
3332 + fi
3333 + fi
3334 + RANLIB=$ac_cv_prog_RANLIB
3335 + if test -n "$RANLIB"; then
3336 +  echo "$as_me:$LINENO: result: $RANLIB" >&5
3337 + echo "${ECHO_T}$RANLIB" >&6
3338 + else
3339 +  echo "$as_me:$LINENO: result: no" >&5
3340 + echo "${ECHO_T}no" >&6
3341 + fi
3342  
3343 <
3344 < ac_ext=f90
3345 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3346 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3347 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3348 < echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3349 < echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3350 < if test "${ac_cv_prog_f90_v+set}" = set; then
3343 > fi
3344 > if test -z "$ac_cv_prog_RANLIB"; then
3345 >  ac_ct_RANLIB=$RANLIB
3346 >  # Extract the first word of "ranlib", so it can be a program name with args.
3347 > set dummy ranlib; ac_word=$2
3348 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3349 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3350 > if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3351    echo $ECHO_N "(cached) $ECHO_C" >&6
3352   else
3353 +  if test -n "$ac_ct_RANLIB"; then
3354 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3355 + else
3356 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3357 + for as_dir in $PATH
3358 + do
3359 +  IFS=$as_save_IFS
3360 +  test -z "$as_dir" && as_dir=.
3361 +  for ac_exec_ext in '' $ac_executable_extensions; do
3362 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3363 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3364 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3365 +    break 2
3366 +  fi
3367 + done
3368 + done
3369  
3370 < cat >conftest.$ac_ext <<_ACEOF
3370 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3371 > fi
3372 > fi
3373 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3374 > if test -n "$ac_ct_RANLIB"; then
3375 >  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3376 > echo "${ECHO_T}$ac_ct_RANLIB" >&6
3377 > else
3378 >  echo "$as_me:$LINENO: result: no" >&5
3379 > echo "${ECHO_T}no" >&6
3380 > fi
3381  
3382 < program main
3382 >  RANLIB=$ac_ct_RANLIB
3383 > else
3384 >  RANLIB="$ac_cv_prog_RANLIB"
3385 > fi
3386  
3387  
3388 < end program main
3388 >   # Extract the first word of "perl", so it can be a program name with args.
3389 > set dummy perl; ac_word=$2
3390 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3391 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3392 > if test "${ac_cv_path_PERLINTERP+set}" = set; then
3393 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3394 > else
3395 >  case $PERLINTERP in
3396 >  [\\/]* | ?:[\\/]*)
3397 >  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3398 >  ;;
3399 >  *)
3400 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3401 > for as_dir in $PATH
3402 > do
3403 >  IFS=$as_save_IFS
3404 >  test -z "$as_dir" && as_dir=.
3405 >  for ac_exec_ext in '' $ac_executable_extensions; do
3406 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3407 >    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3408 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3409 >    break 2
3410 >  fi
3411 > done
3412 > done
3413  
3414 < _ACEOF
3415 < rm -f conftest.$ac_objext
3416 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3417 <  (eval $ac_compile) 2>&5
3418 <  ac_status=$?
3343 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3344 <  (exit $ac_status); } &&
3345 <         { ac_try='test -s conftest.$ac_objext'
3346 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3347 <  (eval $ac_try) 2>&5
3348 <  ac_status=$?
3349 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3350 <  (exit $ac_status); }; }; then
3351 <  ac_cv_prog_f90_v=
3352 < # Try some options frequently used verbose output
3353 < for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3354 <  ac_ext=f90
3355 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3356 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3357 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3414 >  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3415 >  ;;
3416 > esac
3417 > fi
3418 > PERLINTERP=$ac_cv_path_PERLINTERP
3419  
3420 < cat >conftest.$ac_ext <<_ACEOF
3420 > if test -n "$PERLINTERP"; then
3421 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3422 > echo "${ECHO_T}$PERLINTERP" >&6
3423 > else
3424 >  echo "$as_me:$LINENO: result: no" >&5
3425 > echo "${ECHO_T}no" >&6
3426 > fi
3427  
3428 < program main
3428 >   ac_cv_path_perlinterp="$PERLINTERP"
3429 >   _sHpB='#!'
3430  
3431  
3432 < end program main
3432 > # Check whether --with-perl-shebang or --without-perl-shebang was given.
3433 > if test "${with_perl_shebang+set}" = set; then
3434 >  withval="$with_perl_shebang"
3435 >  opt_perl_shebang="$withval"
3436 > else
3437 >                opt_perl_shebang="not_set"
3438 > fi;
3439 >   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3440 > echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3441 > if test "${ax_cv_opt_perl_shebang+set}" = set; then
3442 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3443 > else
3444 >   case "$opt_perl_shebang" in
3445 >                      not_set  ) ax_cv_opt_perl_shebang=''
3446 >                               ;;
3447 >                         *     )
3448 >        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3449 >                    esac
3450  
3451 < _ACEOF
3451 > fi
3452 > echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3453 > echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3454 >   if test "A$ax_cv_opt_perl_shebang" != "A"
3455 >     then
3456 >       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3457 >       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3458 >              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3459 > echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3460  
3461 < # Compile and link our simple test program by passing a flag (argument
3462 < # 1 to this macro) to the Fortran 90 compiler in order to get
3463 < # "verbose" output that we can then parse for the Fortran 90 linker
3464 < # flags.
3465 < ac_save_F90FLAGS=$F90FLAGS
3466 < F90FLAGS="$F90FLAGS $ac_verb"
3461 > # Automatic detection of sharpbang formula starts here
3462 >     else
3463 >   _somian_shbangperl=`$PERLINTERP -V:startperl`
3464 >   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3465 >   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3466 > echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3467 > if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3468 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3469 > else
3470 >  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3471 >        if test "x$_somian_kspb_perl" == x
3472 >          then _somian_ksbp_warn_empty='durnit'
3473 >          else
3474 >          case "A$_somian_kspb_perl" in
3475 >                 A#!*perl* )
3476 >           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3477 >                        ;;
3478 >                     A*    )  _somian_ksbp_warn_defau='trouble'
3479 >                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3480 >          esac
3481 >        fi
3482  
3483 < (eval echo $as_me:3375: \"$ac_link\") >&5
3484 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3485 < echo "$ac_f90_v_output" >&5
3486 < F90FLAGS=$ac_save_F90FLAGS
3483 > fi
3484 > echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3485 > echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3486 > # The above prints Checking ... result message to user.
3487 >   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3488  
3489 < rm -f conftest.*
3490 < ac_ext=f90
3491 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3492 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3493 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3489 >    if test A${_somian_ksbp_warn_empty+set} == Aset
3490 >      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3491 > echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3492 >    fi
3493 > # Inform user after printing result value
3494 >    if test A${_somian_ksbp_warn_defau+set} == Aset
3495 >      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3496 > echo "$as_me: Maybe Not good -" >&6;}
3497 >           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3498 > echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3499 >      else { echo "$as_me:$LINENO: OK Good result - " >&5
3500 > echo "$as_me: OK Good result - " >&6;}
3501 >           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3502 > echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3503 >    fi
3504 >  fi
3505  
3506 < # If we are using xlf then replace all the commas with spaces.
3507 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3508 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3506 > # Find a good install program.  We prefer a C program (faster),
3507 > # so one script is as good as another.  But avoid the broken or
3508 > # incompatible versions:
3509 > # SysV /etc/install, /usr/sbin/install
3510 > # SunOS /usr/etc/install
3511 > # IRIX /sbin/install
3512 > # AIX /bin/install
3513 > # AmigaOS /C/install, which installs bootblocks on floppy discs
3514 > # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3515 > # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3516 > # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3517 > # OS/2's system install, which has a completely different semantic
3518 > # ./install, which can be erroneously created by make from ./install.sh.
3519 > echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3520 > echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3521 > if test -z "$INSTALL"; then
3522 > if test "${ac_cv_path_install+set}" = set; then
3523 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3524 > else
3525 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3526 > for as_dir in $PATH
3527 > do
3528 >  IFS=$as_save_IFS
3529 >  test -z "$as_dir" && as_dir=.
3530 >  # Account for people who put trailing slashes in PATH elements.
3531 > case $as_dir/ in
3532 >  ./ | .// | /cC/* | \
3533 >  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3534 >  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3535 >  /usr/ucb/* ) ;;
3536 >  *)
3537 >    # OSF1 and SCO ODT 3.0 have their own names for install.
3538 >    # Don't use installbsd from OSF since it installs stuff as root
3539 >    # by default.
3540 >    for ac_prog in ginstall scoinst install; do
3541 >      for ac_exec_ext in '' $ac_executable_extensions; do
3542 >        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3543 >          if test $ac_prog = install &&
3544 >            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3545 >            # AIX install.  It has an incompatible calling convention.
3546 >            :
3547 >          elif test $ac_prog = install &&
3548 >            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3549 >            # program-specific install script used by HP pwplus--don't use.
3550 >            :
3551 >          else
3552 >            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3553 >            break 3
3554 >          fi
3555 >        fi
3556 >      done
3557 >    done
3558 >    ;;
3559 > esac
3560 > done
3561 >
3562 >
3563 > fi
3564 >  if test "${ac_cv_path_install+set}" = set; then
3565 >    INSTALL=$ac_cv_path_install
3566 >  else
3567 >    # As a last resort, use the slow shell script.  We don't cache a
3568 >    # path for INSTALL within a source directory, because that will
3569 >    # break other packages using the cache if that directory is
3570 >    # removed, or if the path is relative.
3571 >    INSTALL=$ac_install_sh
3572 >  fi
3573 > fi
3574 > echo "$as_me:$LINENO: result: $INSTALL" >&5
3575 > echo "${ECHO_T}$INSTALL" >&6
3576 >
3577 > # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3578 > # It thinks the first close brace ends the variable substitution.
3579 > test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3580 >
3581 > test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3582 >
3583 > test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3584 >
3585 > case "x$INSTALL" in
3586 >   x/*) ;;
3587 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3588 > esac
3589 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3590 > # Extract the first word of "ar", so it can be a program name with args.
3591 > set dummy ar; ac_word=$2
3592 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3593 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3594 > if test "${ac_cv_prog_AR+set}" = set; then
3595 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3596 > else
3597 >  if test -n "$AR"; then
3598 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3599 > else
3600 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3601 > for as_dir in $PATH
3602 > do
3603 >  IFS=$as_save_IFS
3604 >  test -z "$as_dir" && as_dir=.
3605 >  for ac_exec_ext in '' $ac_executable_extensions; do
3606 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3607 >    ac_cv_prog_AR="ar"
3608 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3609 >    break 2
3610 >  fi
3611 > done
3612 > done
3613 >
3614 >  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3615 > fi
3616 > fi
3617 > AR=$ac_cv_prog_AR
3618 > if test -n "$AR"; then
3619 >  echo "$as_me:$LINENO: result: $AR" >&5
3620 > echo "${ECHO_T}$AR" >&6
3621 > else
3622 >  echo "$as_me:$LINENO: result: no" >&5
3623 > echo "${ECHO_T}no" >&6
3624 > fi
3625 >
3626 > if test "$AR" = "NONE"; then
3627 >  cat >confcache <<\_ACEOF
3628 > # This file is a shell script that caches the results of configure
3629 > # tests run on this system so they can be shared between configure
3630 > # scripts and configure runs, see configure's option --config-cache.
3631 > # It is not useful on other systems.  If it contains results you don't
3632 > # want to keep, you may remove or edit it.
3633 > #
3634 > # config.status only pays attention to the cache file if you give it
3635 > # the --recheck option to rerun configure.
3636 > #
3637 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3638 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3639 > # following values.
3640 >
3641 > _ACEOF
3642 >
3643 > # The following way of writing the cache mishandles newlines in values,
3644 > # but we know of no workaround that is simple, portable, and efficient.
3645 > # So, don't put newlines in cache variables' values.
3646 > # Ultrix sh set writes to stderr and can't be redirected directly,
3647 > # and sets the high bit in the cache file unless we assign to the vars.
3648 > {
3649 >  (set) 2>&1 |
3650 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3651 >    *ac_space=\ *)
3652 >      # `set' does not quote correctly, so add quotes (double-quote
3653 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3654 >      sed -n \
3655 >        "s/'/'\\\\''/g;
3656 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3657 >      ;;
3658 >    *)
3659 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3660 >      sed -n \
3661 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3662 >      ;;
3663 >    esac;
3664 > } |
3665 >  sed '
3666 >     t clear
3667 >     : clear
3668 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3669 >     t end
3670 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3671 >     : end' >>confcache
3672 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3673 >  if test -w $cache_file; then
3674 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3675 >    cat confcache >$cache_file
3676 >  else
3677 >    echo "not updating unwritable cache $cache_file"
3678 >  fi
3679 > fi
3680 > rm -f confcache
3681 >  exit 1
3682 > fi
3683 > # Extract the first word of "ps", so it can be a program name with args.
3684 > set dummy ps; ac_word=$2
3685 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3686 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3687 > if test "${ac_cv_path_PS+set}" = set; then
3688 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3689 > else
3690 >  case $PS in
3691 >  [\\/]* | ?:[\\/]*)
3692 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3693 >  ;;
3694 >  *)
3695 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3696 > for as_dir in $PATH
3697 > do
3698 >  IFS=$as_save_IFS
3699 >  test -z "$as_dir" && as_dir=.
3700 >  for ac_exec_ext in '' $ac_executable_extensions; do
3701 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3702 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3703 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3704 >    break 2
3705 >  fi
3706 > done
3707 > done
3708 >
3709 >  ;;
3710 > esac
3711 > fi
3712 > PS=$ac_cv_path_PS
3713 >
3714 > if test -n "$PS"; then
3715 >  echo "$as_me:$LINENO: result: $PS" >&5
3716 > echo "${ECHO_T}$PS" >&6
3717 > else
3718 >  echo "$as_me:$LINENO: result: no" >&5
3719 > echo "${ECHO_T}no" >&6
3720 > fi
3721 >
3722 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3723 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3724 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3725 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3726 > else
3727 >
3728 >        if $PS ax -o rss > /dev/null 2>&1; then
3729 >                ac_cv_prog_ps_ax=yes
3730 >        else
3731 >                ac_cv_prog_ps_ax=no
3732 >        fi
3733 >        if $PS -ef -o rss > /dev/null 2>&1; then
3734 >                ac_cv_prog_ps_ef=yes
3735 >        else
3736 >                ac_cv_prog_ps_ef=no
3737 >        fi
3738 >        if test "$ac_cv_prog_ps_ax" = yes; then
3739 >                ac_cv_prog_ps_syntax=BSD
3740 >        else
3741 >                if test "$ac_cv_prog_ps_ef" = yes; then
3742 >                        ac_cv_prog_ps_syntax=POSIX
3743 >                else
3744 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3745 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3746 >   { (exit 1); exit 1; }; }
3747 >                fi
3748 >        fi
3749 >
3750 > fi
3751 > echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3752 > echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3753 >
3754 > cat >>confdefs.h <<_ACEOF
3755 > #define PSCOMMAND $PS
3756 > _ACEOF
3757 >
3758 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3759 >
3760 > cat >>confdefs.h <<\_ACEOF
3761 > #define PSTYPE_IS_BSD 1
3762 > _ACEOF
3763 >
3764 > else
3765 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3766 >
3767 > cat >>confdefs.h <<\_ACEOF
3768 > #define PSTYPE_IS_POSIX 1
3769 > _ACEOF
3770 >
3771 >   else
3772 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3773 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3774 >   { (exit 1); exit 1; }; }
3775 >   fi
3776   fi
3777  
3778 < # If we are using Cray Fortran then delete quotes.
3779 < # Use "\"" instead of '"' for font-lock-mode.
3780 < # FIXME: a more general fix for quoted arguments with spaces?
3781 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3782 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3778 > ac_ext=${FC_SRCEXT-f}
3779 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3780 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3781 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3782 >
3783 >
3784 > echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3785 > echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3786 > if test "${ac_cv_fc_srcext_F90+set}" = set; then
3787 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3788 > else
3789 >  ac_ext=F90
3790 > ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3791 > FCFLAGS_SRCEXT=""
3792 > ac_cv_fc_srcext_F90=unknown
3793 > for ac_flag in none -qsuffix=f=F90 -Tf; do
3794 >  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3795 >  cat >conftest.$ac_ext <<_ACEOF
3796 >      program main
3797 >
3798 >      end
3799 > _ACEOF
3800 > rm -f conftest.$ac_objext
3801 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3802 >  (eval $ac_compile) 2>conftest.er1
3803 >  ac_status=$?
3804 >  grep -v '^ *+' conftest.er1 >conftest.err
3805 >  rm -f conftest.er1
3806 >  cat conftest.err >&5
3807 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3808 >  (exit $ac_status); } &&
3809 >         { ac_try='test -z "$ac_fc_werror_flag"
3810 >                         || test ! -s conftest.err'
3811 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3812 >  (eval $ac_try) 2>&5
3813 >  ac_status=$?
3814 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3815 >  (exit $ac_status); }; } &&
3816 >         { ac_try='test -s conftest.$ac_objext'
3817 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3818 >  (eval $ac_try) 2>&5
3819 >  ac_status=$?
3820 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3821 >  (exit $ac_status); }; }; then
3822 >  ac_cv_fc_srcext_F90=$ac_flag; break
3823 > else
3824 >  echo "$as_me: failed program was:" >&5
3825 > sed 's/^/| /' conftest.$ac_ext >&5
3826 >
3827   fi
3828 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3829 + done
3830 + rm -f conftest.$ac_objext conftest.F90
3831 + FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3832 +
3833 + fi
3834 + echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3835 + echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3836 + if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3837 +  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3838 + echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3839 +   { (exit 1); exit 1; }; }
3840 + else
3841 +  FC_SRCEXT=F90
3842 +  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3843 +    FCFLAGS_SRCEXT=""
3844 +    FCFLAGS_F90=""
3845 +  else
3846 +    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3847 +    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3848 +  fi
3849 +
3850 +
3851 + fi
3852 +
3853 +
3854 +
3855 +
3856 +
3857 + # Try to determine native compiler flags that allow us to use F90 suffix
3858 + # for preprocessed f90 source.
3859 +
3860 + if test "$ac_test_PREPFLAG" != "set"; then
3861 +  PREPFLAG=""
3862 +  case "${host_cpu}-${host_os}" in
3863 +
3864 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3865 +                    PREPFLAG="-fpp1 "
3866 +                fi;;
3867 +  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3868 +                    PREPFLAG="-qsuffix=cpp=F90 "
3869 +                fi;;
3870 +  *darwin*)
3871 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3872 +                PREPFLAG="-qsuffix=cpp=F90 "
3873 +        fi;;
3874 +  esac
3875 +
3876 +  if test -z "$PREPFLAG"; then
3877 +        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3878 + echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3879 +        PREPFLAG=""
3880 +  fi
3881 +
3882 +  echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3883 + echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3884 +
3885 +
3886 +  ac_ext=${FC_SRCEXT-f}
3887 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3888 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3889 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3890 +
3891 +  ac_save_ext=$ac_ext
3892 +  ac_ext=F90
3893 +  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3894 +
3895 +  if test "$PREPFLAG"; then
3896 +  FCFLAGS_SRCEXT="${PREPFLAG}"
3897 + fi
3898 +
3899 +    cat >conftest.$ac_ext <<_ACEOF
3900 +
3901 +
3902 + program conftest
3903 +  integer :: i
3904 +  i = 1
3905 + end program conftest
3906 +
3907 + _ACEOF
3908 + rm -f conftest.$ac_objext
3909 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3910 +  (eval $ac_compile) 2>conftest.er1
3911 +  ac_status=$?
3912 +  grep -v '^ *+' conftest.er1 >conftest.err
3913 +  rm -f conftest.er1
3914 +  cat conftest.err >&5
3915 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3916 +  (exit $ac_status); } &&
3917 +         { ac_try='test -z "$ac_fc_werror_flag"
3918 +                         || test ! -s conftest.err'
3919 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3920 +  (eval $ac_try) 2>&5
3921 +  ac_status=$?
3922 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3923 +  (exit $ac_status); }; } &&
3924 +         { ac_try='test -s conftest.$ac_objext'
3925 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3926 +  (eval $ac_try) 2>&5
3927 +  ac_status=$?
3928 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3929 +  (exit $ac_status); }; }; then
3930 +  prepflagworks=1
3931 + else
3932 +  echo "$as_me: failed program was:" >&5
3933 + sed 's/^/| /' conftest.$ac_ext >&5
3934 +
3935 + prepflagworks=0
3936 + fi
3937 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3938 +
3939 +  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3940 +  ac_ext=$ac_save_ext
3941 +  ac_ext=${FC_SRCEXT-f}
3942 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3943 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3944 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3945 +
3946 +
3947 +  if test "$prepflagworks" = 1; then
3948 +    echo "$as_me:$LINENO: result: yes" >&5
3949 + echo "${ECHO_T}yes" >&6
3950 +    FCFLAGS_SRCEXT="${PREPFLAG}"
3951 +
3952 +  else
3953 +    echo "$as_me:$LINENO: result: no" >&5
3954 + echo "${ECHO_T}no" >&6
3955 +    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3956 + echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3957 +   { (exit 1); exit 1; }; }
3958 +  fi
3959 + fi
3960 +
3961 +
3962 +
3963 +
3964 +
3965 + # Try to determine native compiler flags that allow us to use F90 suffix
3966 + # for preprocessed f90 source with -D type defines
3967 +
3968 + if test "$ac_test_PREPDEFFLAG" != "set"; then
3969 +  PREPDEFFLAG=""
3970 +  case "${host_cpu}-${host_os}" in
3971 +
3972 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3973 +                    PREPDEFFLAG=" "
3974 +                fi;;
3975 +  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3976 +                    PREPDEFFLAG="-WF,"
3977 +                fi;;
3978 +  *darwin*)
3979 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3980 +                PREPDEFFLAG="-WF,"
3981 +        fi;;
3982 +  esac
3983 +
3984 +  if test -z "$PREPDEFFLAG"; then
3985 +        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3986 + echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3987 +        PREPDEFFLAG=" "
3988 +  fi
3989 +
3990 +  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3991 + echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3992 +
3993 +
3994 +  ac_ext=${FC_SRCEXT-f}
3995 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3996 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3997 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3998 +
3999 +  ac_save_ext=$ac_ext
4000 +  ac_ext=F90
4001 +  ac_save_FCFLAGS=$FCFLAGS
4002 +
4003 +  if test "$PREPDEFFLAG"; then
4004 +  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
4005 + fi
4006 +
4007 +    cat >conftest.$ac_ext <<_ACEOF
4008 +
4009 +
4010 + program conftest
4011 +  integer :: i
4012 + #ifdef TEST
4013 +  i = 1
4014 + #else
4015 +  choke me
4016 + #endif
4017 + end program conftest
4018 +
4019 + _ACEOF
4020 + rm -f conftest.$ac_objext
4021 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4022 +  (eval $ac_compile) 2>conftest.er1
4023 +  ac_status=$?
4024 +  grep -v '^ *+' conftest.er1 >conftest.err
4025 +  rm -f conftest.er1
4026 +  cat conftest.err >&5
4027 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4028 +  (exit $ac_status); } &&
4029 +         { ac_try='test -z "$ac_fc_werror_flag"
4030 +                         || test ! -s conftest.err'
4031 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4032 +  (eval $ac_try) 2>&5
4033 +  ac_status=$?
4034 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4035 +  (exit $ac_status); }; } &&
4036 +         { ac_try='test -s conftest.$ac_objext'
4037 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4038 +  (eval $ac_try) 2>&5
4039 +  ac_status=$?
4040 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4041 +  (exit $ac_status); }; }; then
4042 +  prepdefflagworks=1
4043 + else
4044 +  echo "$as_me: failed program was:" >&5
4045 + sed 's/^/| /' conftest.$ac_ext >&5
4046 +
4047 + prepdefflagworks=0
4048 + fi
4049 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4050 +
4051 +  FCFLAGS=$ac_save_FCFLAGS
4052 +  ac_ext=$ac_save_ext
4053 +  ac_ext=${FC_SRCEXT-f}
4054 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4055 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4056 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4057 +
4058 +
4059 +  if test "$prepdefflagworks" = 1; then
4060 +    echo "$as_me:$LINENO: result: yes" >&5
4061 + echo "${ECHO_T}yes" >&6
4062 +
4063 +  else
4064 +    echo "$as_me:$LINENO: result: no" >&5
4065 + echo "${ECHO_T}no" >&6
4066 +    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
4067 + echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
4068 +   { (exit 1); exit 1; }; }
4069 +  fi
4070 + fi
4071 +
4072 + ac_ext=${FC_SRCEXT-f}
4073 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4074 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4075 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4076 + echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4077 + echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4078 + if test "${ac_cv_prog_fc_v+set}" = set; then
4079 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4080 + else
4081 +  cat >conftest.$ac_ext <<_ACEOF
4082 +      program main
4083 +
4084 +      end
4085 + _ACEOF
4086 + rm -f conftest.$ac_objext
4087 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4088 +  (eval $ac_compile) 2>conftest.er1
4089 +  ac_status=$?
4090 +  grep -v '^ *+' conftest.er1 >conftest.err
4091 +  rm -f conftest.er1
4092 +  cat conftest.err >&5
4093 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4094 +  (exit $ac_status); } &&
4095 +         { ac_try='test -z "$ac_fc_werror_flag"
4096 +                         || test ! -s conftest.err'
4097 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4098 +  (eval $ac_try) 2>&5
4099 +  ac_status=$?
4100 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4101 +  (exit $ac_status); }; } &&
4102 +         { ac_try='test -s conftest.$ac_objext'
4103 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4104 +  (eval $ac_try) 2>&5
4105 +  ac_status=$?
4106 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4107 +  (exit $ac_status); }; }; then
4108 +  ac_cv_prog_fc_v=
4109 + # Try some options frequently used verbose output
4110 + for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4111 +  cat >conftest.$ac_ext <<_ACEOF
4112 +      program main
4113 +
4114 +      end
4115 + _ACEOF
4116 +
4117 + # Compile and link our simple test program by passing a flag (argument
4118 + # 1 to this macro) to the Fortran compiler in order to get
4119 + # "verbose" output that we can then parse for the Fortran linker
4120 + # flags.
4121 + ac_save_FFLAGS=$FCFLAGS
4122 + FCFLAGS="$FCFLAGS $ac_verb"
4123 + (eval echo $as_me:4123: \"$ac_link\") >&5
4124 + ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4125 + echo "$ac_fc_v_output" >&5
4126 + FCFLAGS=$ac_save_FFLAGS
4127 +
4128 + rm -f conftest*
4129 +
4130 + # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4131 + # /foo, /bar, and /baz are search directories for the Fortran linker.
4132 + # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4133 + ac_fc_v_output="`echo $ac_fc_v_output |
4134 +        grep 'LPATH is:' |
4135 +        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4136 +
4137 + case $ac_fc_v_output in
4138 +  # If we are using xlf then replace all the commas with spaces.
4139 +  *xlfentry*)
4140 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4141 +
4142 +  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4143 +  # $LIBS confuse us, and the libraries appear later in the output anyway).
4144 +  *mGLOB_options_string*)
4145 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4146 +
4147 +  # If we are using Cray Fortran then delete quotes.
4148 +  # Use "\"" instead of '"' for font-lock-mode.
4149 +  # FIXME: a more general fix for quoted arguments with spaces?
4150 +  *cft90*)
4151 +    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4152 + esac
4153 +
4154 +
4155    # look for -l* and *.a constructs in the output
4156 <  for ac_arg in $ac_f90_v_output; do
4156 >  for ac_arg in $ac_fc_v_output; do
4157       case $ac_arg in
4158          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4159 <          ac_cv_prog_f90_v=$ac_verb
4159 >          ac_cv_prog_fc_v=$ac_verb
4160            break 2 ;;
4161       esac
4162    done
4163   done
4164 < if test -z "$ac_cv_prog_f90_v"; then
4165 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4166 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4164 > if test -z "$ac_cv_prog_fc_v"; then
4165 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4166 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4167   fi
4168   else
4169    echo "$as_me: failed program was:" >&5
# Line 3414 | Line 4172 | fi
4172   { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4173   echo "$as_me: WARNING: compilation failed" >&2;}
4174   fi
4175 < rm -f conftest.$ac_objext conftest.$ac_ext
4175 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4176  
4177   fi
4178 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4179 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4180 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4181 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4182 < if test "${ac_cv_flibs+set}" = set; then
4178 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4179 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4180 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4181 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4182 > if test "${ac_cv_fc_libs+set}" = set; then
4183    echo $ECHO_N "(cached) $ECHO_C" >&6
4184   else
4185 <  if test "x$F90LIBS" != "x"; then
4186 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4185 >  if test "x$FCLIBS" != "x"; then
4186 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4187   else
4188  
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
4189   cat >conftest.$ac_ext <<_ACEOF
4190 +      program main
4191  
4192 < program main
3439 <
3440 <
3441 < end program main
3442 <
4192 >      end
4193   _ACEOF
4194  
4195   # Compile and link our simple test program by passing a flag (argument
4196 < # 1 to this macro) to the Fortran 90 compiler in order to get
4197 < # "verbose" output that we can then parse for the Fortran 90 linker
4196 > # 1 to this macro) to the Fortran compiler in order to get
4197 > # "verbose" output that we can then parse for the Fortran linker
4198   # flags.
4199 < ac_save_F90FLAGS=$F90FLAGS
4200 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4199 > ac_save_FFLAGS=$FCFLAGS
4200 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4201 > (eval echo $as_me:4201: \"$ac_link\") >&5
4202 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4203 > echo "$ac_fc_v_output" >&5
4204 > FCFLAGS=$ac_save_FFLAGS
4205  
4206 < (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
4206 > rm -f conftest*
4207  
4208 < rm -f conftest.*
4209 < ac_ext=f90
4210 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4211 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4212 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4208 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4209 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4210 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4211 > ac_fc_v_output="`echo $ac_fc_v_output |
4212 >        grep 'LPATH is:' |
4213 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4214  
4215 < # If we are using xlf then replace all the commas with spaces.
4216 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4217 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4218 < fi
4215 > case $ac_fc_v_output in
4216 >  # If we are using xlf then replace all the commas with spaces.
4217 >  *xlfentry*)
4218 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4219  
4220 < # If we are using Cray Fortran then delete quotes.
4221 < # Use "\"" instead of '"' for font-lock-mode.
4222 < # FIXME: a more general fix for quoted arguments with spaces?
4223 < 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
4220 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4221 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4222 >  *mGLOB_options_string*)
4223 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4224  
4225 < ac_cv_f90libs=
4225 >  # If we are using Cray Fortran then delete quotes.
4226 >  # Use "\"" instead of '"' for font-lock-mode.
4227 >  # FIXME: a more general fix for quoted arguments with spaces?
4228 >  *cft90*)
4229 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4230 > esac
4231  
4232 +
4233 +
4234 + ac_cv_fc_libs=
4235 +
4236   # Save positional arguments (if any)
4237   ac_save_positional="$@"
4238  
4239 < set X $ac_f90_v_output
4239 > set X $ac_fc_v_output
4240   while test $# != 1; do
4241    shift
4242    ac_arg=$1
4243    case $ac_arg in
4244          [\\/]*.a | ?:[\\/]*.a)
4245              ac_exists=false
4246 <  for ac_i in $ac_cv_f90libs; do
4246 >  for ac_i in $ac_cv_fc_libs; do
4247      if test x"$ac_arg" = x"$ac_i"; then
4248        ac_exists=true
4249        break
# Line 3494 | Line 4253 | else
4253    if test x"$ac_exists" = xtrue; then
4254    :
4255   else
4256 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4256 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4257   fi
4258  
4259            ;;
4260          -bI:*)
4261              ac_exists=false
4262 <  for ac_i in $ac_cv_f90libs; do
4262 >  for ac_i in $ac_cv_fc_libs; do
4263      if test x"$ac_arg" = x"$ac_i"; then
4264        ac_exists=true
4265        break
# Line 3512 | Line 4271 | else
4271   else
4272    if test "$ac_compiler_gnu" = yes; then
4273    for ac_link_opt in $ac_arg; do
4274 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4274 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4275    done
4276   else
4277 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4277 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4278   fi
4279   fi
4280  
4281            ;;
4282            # Ignore these flags.
4283 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4283 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4284            ;;
4285          -lkernel32)
4286 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4286 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4287            ;;
4288          -[LRuY])
4289            # These flags, when seen by themselves, take an argument.
4290            # We remove the space between option and argument and re-iterate
4291            # unless we find an empty arg or a new option (starting with -)
4292            case $2 in
4293 <             "" | -*);;
4294 <             *)
4293 >             "" | -*);;
4294 >             *)
4295                  ac_arg="$ac_arg$2"
3537
4296                  shift; shift
4297                  set X $ac_arg "$@"
4298                  ;;
# Line 3543 | Line 4301 | fi
4301          -YP,*)
4302            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4303                ac_exists=false
4304 <  for ac_i in $ac_cv_f90libs; do
4304 >  for ac_i in $ac_cv_fc_libs; do
4305      if test x"$ac_j" = x"$ac_i"; then
4306        ac_exists=true
4307        break
# Line 3554 | Line 4312 | else
4312    :
4313   else
4314    ac_arg="$ac_arg $ac_j"
4315 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4315 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4316   fi
4317  
4318            done
4319            ;;
4320          -[lLR]*)
4321              ac_exists=false
4322 <  for ac_i in $ac_cv_f90libs; do
4322 >  for ac_i in $ac_cv_fc_libs; do
4323      if test x"$ac_arg" = x"$ac_i"; then
4324        ac_exists=true
4325        break
# Line 3571 | Line 4329 | else
4329    if test x"$ac_exists" = xtrue; then
4330    :
4331   else
4332 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4332 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4333   fi
4334  
4335            ;;
# Line 3586 | Line 4344 | case `(uname -sr) 2>/dev/null` in
4344   # must begin with a "/").
4345   case `(uname -sr) 2>/dev/null` in
4346     "SunOS 5"*)
4347 <      ac_ld_run_path=`echo $ac_f90_v_output |
4347 >      ac_ld_run_path=`echo $ac_fc_v_output |
4348                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4349        test "x$ac_ld_run_path" != x &&
3592
4350          if test "$ac_compiler_gnu" = yes; then
4351    for ac_link_opt in $ac_ld_run_path; do
4352 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4352 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4353    done
4354   else
4355 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4356 < fi
4357 <      ;;
4358 < esac
4359 < fi # test "x$F90LIBS" = "x"
4360 <
4361 < fi
4362 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4363 < echo "${ECHO_T}$ac_cv_flibs" >&6
4364 < F90LIBS="$ac_cv_f90libs"
4365 <
4366 < ac_ext=f90
4367 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4368 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4369 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4370 <
4371 <
4372 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4373 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4374 < if test "${ac_cv_f90_mangling+set}" = set; then
4375 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4376 < else
4377 <  ac_ext=f90
4378 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4379 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4380 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4381 < cat >conftest.$ac_ext <<_ACEOF
4382 < subroutine foobar()
4383 < return
4384 < end
4385 < subroutine foo_bar()
4386 < return
4387 < end
4388 < _ACEOF
4389 < rm -f conftest.$ac_objext
4390 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4391 <  (eval $ac_compile) 2>&5
4392 <  ac_status=$?
4393 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4394 <  (exit $ac_status); } &&
4395 <         { ac_try='test -s conftest.$ac_objext'
4396 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4397 <  (eval $ac_try) 2>&5
4398 <  ac_status=$?
4399 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4400 <  (exit $ac_status); }; }; then
4401 <  mv conftest.$ac_objext cf90_test.$ac_objext
4402 <
4403 <  ac_ext=c
4404 < ac_cpp='$CPP $CPPFLAGS'
4405 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4406 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4407 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4408 <
4409 <  ac_save_LIBS=$LIBS
4410 <  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
4411 <
4412 <  ac_success=no
4413 <  for ac_foobar in foobar FOOBAR; do
4414 <    for ac_underscore in "" "_"; do
4415 <      ac_func="$ac_foobar$ac_underscore"
4416 <      cat >conftest.$ac_ext <<_ACEOF
4417 < #line $LINENO "configure"
4418 < /* confdefs.h.  */
4419 < _ACEOF
4420 < cat confdefs.h >>conftest.$ac_ext
4421 < cat >>conftest.$ac_ext <<_ACEOF
4422 < /* end confdefs.h.  */
4423 <
4424 < /* Override any gcc2 internal prototype to avoid an error.  */
4425 < #ifdef __cplusplus
4426 < extern "C"
4427 < #endif
4428 < /* We use char because int might match the return type of a gcc2
4429 <   builtin and then its argument prototype would still apply.  */
4430 < char $ac_func ();
4431 < int
4432 < main ()
4433 < {
4434 < $ac_func ();
4435 <  ;
4436 <  return 0;
4437 < }
4438 < _ACEOF
4439 < rm -f conftest.$ac_objext conftest$ac_exeext
4440 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4441 <  (eval $ac_link) 2>&5
4442 <  ac_status=$?
4443 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4444 <  (exit $ac_status); } &&
4445 <         { ac_try='test -s conftest$ac_exeext'
4446 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4447 <  (eval $ac_try) 2>&5
4448 <  ac_status=$?
4449 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4450 <  (exit $ac_status); }; }; then
4451 <  ac_success=yes; break 2
4452 < else
4453 <  echo "$as_me: failed program was:" >&5
4454 < sed 's/^/| /' conftest.$ac_ext >&5
4455 <
4456 < fi
4457 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
4458 <    done
4459 <  done
4460 <
4461 <  if test "$ac_success" = "yes"; then
4462 <     case $ac_foobar in
4463 <        foobar)
4464 <           ac_case=lower
4465 <           ac_foo_bar=foo_bar
4466 <           ;;
4467 <        FOOBAR)
4468 <           ac_case=upper
4469 <           ac_foo_bar=FOO_BAR
4470 <           ;;
4471 <     esac
4472 <
4473 <     ac_success_extra=no
4474 <     for ac_extra in "" "_"; do
4475 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4476 <
4477 <        cat >conftest.$ac_ext <<_ACEOF
4478 < #line $LINENO "configure"
4479 < /* confdefs.h.  */
4480 < _ACEOF
4481 < cat confdefs.h >>conftest.$ac_ext
4482 < cat >>conftest.$ac_ext <<_ACEOF
4483 < /* end confdefs.h.  */
4484 <
4485 < /* Override any gcc2 internal prototype to avoid an error.  */
4486 < #ifdef __cplusplus
4487 < extern "C"
4488 < #endif
4489 < /* We use char because int might match the return type of a gcc2
4490 <   builtin and then its argument prototype would still apply.  */
4491 < char $ac_func ();
4492 < int
4493 < main ()
4494 < {
4495 < $ac_func ();
4496 <  ;
4497 <  return 0;
4498 < }
4499 < _ACEOF
4500 < rm -f conftest.$ac_objext conftest$ac_exeext
4501 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4502 <  (eval $ac_link) 2>&5
4503 <  ac_status=$?
4504 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4505 <  (exit $ac_status); } &&
4506 <         { ac_try='test -s conftest$ac_exeext'
4507 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4508 <  (eval $ac_try) 2>&5
4509 <  ac_status=$?
4510 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4511 <  (exit $ac_status); }; }; then
4512 <  ac_success_extra=yes; break
4513 < else
4514 <  echo "$as_me: failed program was:" >&5
4515 < sed 's/^/| /' conftest.$ac_ext >&5
4516 <
4517 < fi
4518 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
4519 <     done
4520 <
4521 <     if test "$ac_success_extra" = "yes"; then
4522 <        ac_cv_f90_mangling="$ac_case case"
4523 <        if test -z "$ac_underscore"; then
4524 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4525 <        else
4526 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4527 <
4528 <        fi
4529 <        if test -z "$ac_extra"; then
4530 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4531 <        else
4532 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4533 <        fi
4534 <      else
4535 <        ac_cv_f90_mangling="unknown"
4536 <      fi
4537 <  else
4538 <     ac_cv_f90_mangling="unknown"
4539 <
4540 <  fi
4541 <
4542 <  LIBS=$ac_save_LIBS
4543 <  ac_ext=f90
4544 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4545 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4546 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4547 <  rm -f cf90_test* conftest*
4548 < else
4549 <  echo "$as_me: failed program was:" >&5
4550 < sed 's/^/| /' conftest.$ac_ext >&5
4551 <
4552 < fi
4553 < rm -f conftest.$ac_objext conftest.$ac_ext
4554 < ac_ext=f90
4555 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4556 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4557 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4558 <
4559 < fi
4560 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4561 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4562 <
4563 <
4564 <
4565 < case $ac_cv_f90_mangling in
4566 <  "lower case, no underscore, no extra underscore")
4567 <          cat >>confdefs.h <<\_ACEOF
4568 < #define F90_FUNC(name,NAME) name
4569 < _ACEOF
4570 <
4571 <          cat >>confdefs.h <<\_ACEOF
4572 < #define F90_FUNC_(name,NAME) name
4573 < _ACEOF
4574 < ;;
4575 <  "lower case, no underscore, extra underscore")
4576 <          cat >>confdefs.h <<\_ACEOF
4577 < #define F90_FUNC(name,NAME) name
4578 < _ACEOF
4579 <
4580 <          cat >>confdefs.h <<\_ACEOF
4581 < #define F90_FUNC_(name,NAME) name ## _
4582 < _ACEOF
4583 < ;;
4584 <  "lower case, underscore, no extra underscore")
4585 <          cat >>confdefs.h <<\_ACEOF
4586 < #define F90_FUNC(name,NAME) name ## _
4587 < _ACEOF
4588 <
4589 <          cat >>confdefs.h <<\_ACEOF
4590 < #define F90_FUNC_(name,NAME) name ## _
4591 < _ACEOF
4592 < ;;
4593 <  "lower case, underscore, extra underscore")
4594 <          cat >>confdefs.h <<\_ACEOF
4595 < #define F90_FUNC(name,NAME) name ## _
4596 < _ACEOF
4597 <
4598 <          cat >>confdefs.h <<\_ACEOF
4599 < #define F90_FUNC_(name,NAME) name ## __
4355 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4356 > fi
4357 >      ;;
4358 > esac
4359 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4360 >
4361 > fi
4362 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4363 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4364 > FCLIBS="$ac_cv_fc_libs"
4365 >
4366 >
4367 > ac_ext=${FC_SRCEXT-f}
4368 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4369 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4370 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4371 >
4372 >
4373 > ac_ext=${FC_SRCEXT-f}
4374 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4375 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4376 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4377 >
4378 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4379 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4380 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4381 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4382 > else
4383 >  ac_fc_dm_save_LIBS=$LIBS
4384 > LIBS="$LIBS $FCLIBS"
4385 > ac_fortran_dm_var=FC_DUMMY_MAIN
4386 > ac_ext=c
4387 > ac_cpp='$CPP $CPPFLAGS'
4388 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4389 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4390 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4391 >
4392 > # First, try linking without a dummy main:
4393 > cat >conftest.$ac_ext <<_ACEOF
4394 > /* confdefs.h.  */
4395 > _ACEOF
4396 > cat confdefs.h >>conftest.$ac_ext
4397 > cat >>conftest.$ac_ext <<_ACEOF
4398 > /* end confdefs.h.  */
4399 >
4400 > #ifdef FC_DUMMY_MAIN
4401 > #ifndef FC_DUMMY_MAIN_EQ_F77
4402 > #  ifdef __cplusplus
4403 >     extern "C"
4404 > #  endif
4405 >   int FC_DUMMY_MAIN() { return 1; }
4406 > #endif
4407 > #endif
4408 > int
4409 > main ()
4410 > {
4411 >
4412 >  ;
4413 >  return 0;
4414 > }
4415 > _ACEOF
4416 > rm -f conftest.$ac_objext conftest$ac_exeext
4417 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4418 >  (eval $ac_link) 2>conftest.er1
4419 >  ac_status=$?
4420 >  grep -v '^ *+' conftest.er1 >conftest.err
4421 >  rm -f conftest.er1
4422 >  cat conftest.err >&5
4423 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4424 >  (exit $ac_status); } &&
4425 >         { ac_try='test -z "$ac_c_werror_flag"
4426 >                         || test ! -s conftest.err'
4427 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4428 >  (eval $ac_try) 2>&5
4429 >  ac_status=$?
4430 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4431 >  (exit $ac_status); }; } &&
4432 >         { ac_try='test -s conftest$ac_exeext'
4433 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4434 >  (eval $ac_try) 2>&5
4435 >  ac_status=$?
4436 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4437 >  (exit $ac_status); }; }; then
4438 >  ac_cv_fortran_dummy_main=none
4439 > else
4440 >  echo "$as_me: failed program was:" >&5
4441 > sed 's/^/| /' conftest.$ac_ext >&5
4442 >
4443 > ac_cv_fortran_dummy_main=unknown
4444 > fi
4445 > rm -f conftest.err conftest.$ac_objext \
4446 >      conftest$ac_exeext conftest.$ac_ext
4447 >
4448 > if test $ac_cv_fortran_dummy_main = unknown; then
4449 >   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4450 >     cat >conftest.$ac_ext <<_ACEOF
4451 > /* confdefs.h.  */
4452 > _ACEOF
4453 > cat confdefs.h >>conftest.$ac_ext
4454 > cat >>conftest.$ac_ext <<_ACEOF
4455 > /* end confdefs.h.  */
4456 > #define $ac_fortran_dm_var $ac_func
4457 > #ifdef FC_DUMMY_MAIN
4458 > #ifndef FC_DUMMY_MAIN_EQ_F77
4459 > #  ifdef __cplusplus
4460 >     extern "C"
4461 > #  endif
4462 >   int FC_DUMMY_MAIN() { return 1; }
4463 > #endif
4464 > #endif
4465 > int
4466 > main ()
4467 > {
4468 >
4469 >  ;
4470 >  return 0;
4471 > }
4472 > _ACEOF
4473 > rm -f conftest.$ac_objext conftest$ac_exeext
4474 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4475 >  (eval $ac_link) 2>conftest.er1
4476 >  ac_status=$?
4477 >  grep -v '^ *+' conftest.er1 >conftest.err
4478 >  rm -f conftest.er1
4479 >  cat conftest.err >&5
4480 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4481 >  (exit $ac_status); } &&
4482 >         { ac_try='test -z "$ac_c_werror_flag"
4483 >                         || test ! -s conftest.err'
4484 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4485 >  (eval $ac_try) 2>&5
4486 >  ac_status=$?
4487 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4488 >  (exit $ac_status); }; } &&
4489 >         { ac_try='test -s conftest$ac_exeext'
4490 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4491 >  (eval $ac_try) 2>&5
4492 >  ac_status=$?
4493 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4494 >  (exit $ac_status); }; }; then
4495 >  ac_cv_fortran_dummy_main=$ac_func; break
4496 > else
4497 >  echo "$as_me: failed program was:" >&5
4498 > sed 's/^/| /' conftest.$ac_ext >&5
4499 >
4500 > fi
4501 > rm -f conftest.err conftest.$ac_objext \
4502 >      conftest$ac_exeext conftest.$ac_ext
4503 >   done
4504 > fi
4505 > ac_ext=${FC_SRCEXT-f}
4506 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4507 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4508 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4509 > ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4510 > rm -f conftest*
4511 > LIBS=$ac_fc_dm_save_LIBS
4512 >
4513 > fi
4514 > echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4515 > echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4516 > FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4517 > if test "$FC_DUMMY_MAIN" != unknown; then
4518 >  if test $FC_DUMMY_MAIN != none; then
4519 >
4520 > cat >>confdefs.h <<_ACEOF
4521 > #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4522 > _ACEOF
4523 >
4524 >  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4525 >
4526 > cat >>confdefs.h <<\_ACEOF
4527 > #define FC_DUMMY_MAIN_EQ_F77 1
4528 > _ACEOF
4529 >
4530 >  fi
4531 > fi
4532 > else
4533 >  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4534 > See \`config.log' for more details." >&5
4535 > echo "$as_me: error: linking to Fortran libraries from C fails
4536 > See \`config.log' for more details." >&2;}
4537 >   { (exit 1); exit 1; }; }
4538 > fi
4539 >
4540 >
4541 > ac_ext=${FC_SRCEXT-f}
4542 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4543 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4544 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4545 >
4546 > ac_ext=${FC_SRCEXT-f}
4547 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4548 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4549 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4550 > echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4551 > echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4552 > if test "${ac_cv_fc_mangling+set}" = set; then
4553 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4554 > else
4555 >  cat >conftest.$ac_ext <<_ACEOF
4556 >      subroutine foobar()
4557 >      return
4558 >      end
4559 >      subroutine foo_bar()
4560 >      return
4561 >      end
4562 > _ACEOF
4563 > rm -f conftest.$ac_objext
4564 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4565 >  (eval $ac_compile) 2>conftest.er1
4566 >  ac_status=$?
4567 >  grep -v '^ *+' conftest.er1 >conftest.err
4568 >  rm -f conftest.er1
4569 >  cat conftest.err >&5
4570 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4571 >  (exit $ac_status); } &&
4572 >         { ac_try='test -z "$ac_fc_werror_flag"
4573 >                         || test ! -s conftest.err'
4574 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4575 >  (eval $ac_try) 2>&5
4576 >  ac_status=$?
4577 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4578 >  (exit $ac_status); }; } &&
4579 >         { ac_try='test -s conftest.$ac_objext'
4580 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4581 >  (eval $ac_try) 2>&5
4582 >  ac_status=$?
4583 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4584 >  (exit $ac_status); }; }; then
4585 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4586 >
4587 >  ac_save_LIBS=$LIBS
4588 >  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4589 >
4590 >  ac_ext=c
4591 > ac_cpp='$CPP $CPPFLAGS'
4592 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4593 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4594 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4595 >  ac_success=no
4596 >  for ac_foobar in foobar FOOBAR; do
4597 >    for ac_underscore in "" "_"; do
4598 >      ac_func="$ac_foobar$ac_underscore"
4599 >      cat >conftest.$ac_ext <<_ACEOF
4600 > /* confdefs.h.  */
4601 > _ACEOF
4602 > cat confdefs.h >>conftest.$ac_ext
4603 > cat >>conftest.$ac_ext <<_ACEOF
4604 > /* end confdefs.h.  */
4605 >
4606 > /* Override any gcc2 internal prototype to avoid an error.  */
4607 > #ifdef __cplusplus
4608 > extern "C"
4609 > #endif
4610 > /* We use char because int might match the return type of a gcc2
4611 >   builtin and then its argument prototype would still apply.  */
4612 > char $ac_func ();
4613 > #ifdef FC_DUMMY_MAIN
4614 > #ifndef FC_DUMMY_MAIN_EQ_F77
4615 > #  ifdef __cplusplus
4616 >     extern "C"
4617 > #  endif
4618 >   int FC_DUMMY_MAIN() { return 1; }
4619 > #endif
4620 > #endif
4621 > int
4622 > main ()
4623 > {
4624 > $ac_func ();
4625 >  ;
4626 >  return 0;
4627 > }
4628 > _ACEOF
4629 > rm -f conftest.$ac_objext conftest$ac_exeext
4630 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4631 >  (eval $ac_link) 2>conftest.er1
4632 >  ac_status=$?
4633 >  grep -v '^ *+' conftest.er1 >conftest.err
4634 >  rm -f conftest.er1
4635 >  cat conftest.err >&5
4636 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4637 >  (exit $ac_status); } &&
4638 >         { ac_try='test -z "$ac_c_werror_flag"
4639 >                         || test ! -s conftest.err'
4640 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4641 >  (eval $ac_try) 2>&5
4642 >  ac_status=$?
4643 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4644 >  (exit $ac_status); }; } &&
4645 >         { ac_try='test -s conftest$ac_exeext'
4646 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4647 >  (eval $ac_try) 2>&5
4648 >  ac_status=$?
4649 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4650 >  (exit $ac_status); }; }; then
4651 >  ac_success=yes; break 2
4652 > else
4653 >  echo "$as_me: failed program was:" >&5
4654 > sed 's/^/| /' conftest.$ac_ext >&5
4655 >
4656 > fi
4657 > rm -f conftest.err conftest.$ac_objext \
4658 >      conftest$ac_exeext conftest.$ac_ext
4659 >    done
4660 >  done
4661 >  ac_ext=${FC_SRCEXT-f}
4662 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4663 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4664 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4665 >
4666 >  if test "$ac_success" = "yes"; then
4667 >     case $ac_foobar in
4668 >        foobar)
4669 >           ac_case=lower
4670 >           ac_foo_bar=foo_bar
4671 >           ;;
4672 >        FOOBAR)
4673 >           ac_case=upper
4674 >           ac_foo_bar=FOO_BAR
4675 >           ;;
4676 >     esac
4677 >
4678 >     ac_ext=c
4679 > ac_cpp='$CPP $CPPFLAGS'
4680 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4681 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4682 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4683 >     ac_success_extra=no
4684 >     for ac_extra in "" "_"; do
4685 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4686 >        cat >conftest.$ac_ext <<_ACEOF
4687 > /* confdefs.h.  */
4688 > _ACEOF
4689 > cat confdefs.h >>conftest.$ac_ext
4690 > cat >>conftest.$ac_ext <<_ACEOF
4691 > /* end confdefs.h.  */
4692 >
4693 > /* Override any gcc2 internal prototype to avoid an error.  */
4694 > #ifdef __cplusplus
4695 > extern "C"
4696 > #endif
4697 > /* We use char because int might match the return type of a gcc2
4698 >   builtin and then its argument prototype would still apply.  */
4699 > char $ac_func ();
4700 > #ifdef FC_DUMMY_MAIN
4701 > #ifndef FC_DUMMY_MAIN_EQ_F77
4702 > #  ifdef __cplusplus
4703 >     extern "C"
4704 > #  endif
4705 >   int FC_DUMMY_MAIN() { return 1; }
4706 > #endif
4707 > #endif
4708 > int
4709 > main ()
4710 > {
4711 > $ac_func ();
4712 >  ;
4713 >  return 0;
4714 > }
4715 > _ACEOF
4716 > rm -f conftest.$ac_objext conftest$ac_exeext
4717 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4718 >  (eval $ac_link) 2>conftest.er1
4719 >  ac_status=$?
4720 >  grep -v '^ *+' conftest.er1 >conftest.err
4721 >  rm -f conftest.er1
4722 >  cat conftest.err >&5
4723 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4724 >  (exit $ac_status); } &&
4725 >         { ac_try='test -z "$ac_c_werror_flag"
4726 >                         || test ! -s conftest.err'
4727 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4728 >  (eval $ac_try) 2>&5
4729 >  ac_status=$?
4730 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4731 >  (exit $ac_status); }; } &&
4732 >         { ac_try='test -s conftest$ac_exeext'
4733 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4734 >  (eval $ac_try) 2>&5
4735 >  ac_status=$?
4736 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4737 >  (exit $ac_status); }; }; then
4738 >  ac_success_extra=yes; break
4739 > else
4740 >  echo "$as_me: failed program was:" >&5
4741 > sed 's/^/| /' conftest.$ac_ext >&5
4742 >
4743 > fi
4744 > rm -f conftest.err conftest.$ac_objext \
4745 >      conftest$ac_exeext conftest.$ac_ext
4746 >     done
4747 >     ac_ext=${FC_SRCEXT-f}
4748 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4749 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4750 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4751 >
4752 >     if test "$ac_success_extra" = "yes"; then
4753 >        ac_cv_fc_mangling="$ac_case case"
4754 >        if test -z "$ac_underscore"; then
4755 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4756 >        else
4757 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4758 >        fi
4759 >        if test -z "$ac_extra"; then
4760 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4761 >        else
4762 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4763 >        fi
4764 >      else
4765 >        ac_cv_fc_mangling="unknown"
4766 >      fi
4767 >  else
4768 >     ac_cv_fc_mangling="unknown"
4769 >  fi
4770 >
4771 >  LIBS=$ac_save_LIBS
4772 >  rm -f cfortran_test* conftest*
4773 > else
4774 >  echo "$as_me: failed program was:" >&5
4775 > sed 's/^/| /' conftest.$ac_ext >&5
4776 >
4777 > { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4778 > See \`config.log' for more details." >&5
4779 > echo "$as_me: error: cannot compile a simple Fortran program
4780 > See \`config.log' for more details." >&2;}
4781 >   { (exit 1); exit 1; }; }
4782 > fi
4783 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4784 >
4785 > fi
4786 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4787 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4788 >
4789 > ac_ext=${FC_SRCEXT-f}
4790 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4791 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4792 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4793 >
4794 > ac_ext=${FC_SRCEXT-f}
4795 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4796 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4797 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4798 >
4799 >
4800 > case $ac_cv_fc_mangling in
4801 >  "lower case, no underscore, no extra underscore")
4802 >          cat >>confdefs.h <<\_ACEOF
4803 > #define FC_FUNC(name,NAME) name
4804 > _ACEOF
4805 >
4806 >          cat >>confdefs.h <<\_ACEOF
4807 > #define FC_FUNC_(name,NAME) name
4808 > _ACEOF
4809 > ;;
4810 >  "lower case, no underscore, extra underscore")
4811 >          cat >>confdefs.h <<\_ACEOF
4812 > #define FC_FUNC(name,NAME) name
4813 > _ACEOF
4814 >
4815 >          cat >>confdefs.h <<\_ACEOF
4816 > #define FC_FUNC_(name,NAME) name ## _
4817 > _ACEOF
4818 > ;;
4819 >  "lower case, underscore, no extra underscore")
4820 >          cat >>confdefs.h <<\_ACEOF
4821 > #define FC_FUNC(name,NAME) name ## _
4822 > _ACEOF
4823 >
4824 >          cat >>confdefs.h <<\_ACEOF
4825 > #define FC_FUNC_(name,NAME) name ## _
4826 > _ACEOF
4827 > ;;
4828 >  "lower case, underscore, extra underscore")
4829 >          cat >>confdefs.h <<\_ACEOF
4830 > #define FC_FUNC(name,NAME) name ## _
4831 > _ACEOF
4832 >
4833 >          cat >>confdefs.h <<\_ACEOF
4834 > #define FC_FUNC_(name,NAME) name ## __
4835 > _ACEOF
4836 > ;;
4837 >  "upper case, no underscore, no extra underscore")
4838 >          cat >>confdefs.h <<\_ACEOF
4839 > #define FC_FUNC(name,NAME) NAME
4840 > _ACEOF
4841 >
4842 >          cat >>confdefs.h <<\_ACEOF
4843 > #define FC_FUNC_(name,NAME) NAME
4844 > _ACEOF
4845 > ;;
4846 >  "upper case, no underscore, extra underscore")
4847 >          cat >>confdefs.h <<\_ACEOF
4848 > #define FC_FUNC(name,NAME) NAME
4849 > _ACEOF
4850 >
4851 >          cat >>confdefs.h <<\_ACEOF
4852 > #define FC_FUNC_(name,NAME) NAME ## _
4853 > _ACEOF
4854 > ;;
4855 >  "upper case, underscore, no extra underscore")
4856 >          cat >>confdefs.h <<\_ACEOF
4857 > #define FC_FUNC(name,NAME) NAME ## _
4858 > _ACEOF
4859 >
4860 >          cat >>confdefs.h <<\_ACEOF
4861 > #define FC_FUNC_(name,NAME) NAME ## _
4862 > _ACEOF
4863 > ;;
4864 >  "upper case, underscore, extra underscore")
4865 >          cat >>confdefs.h <<\_ACEOF
4866 > #define FC_FUNC(name,NAME) NAME ## _
4867 > _ACEOF
4868 >
4869 >          cat >>confdefs.h <<\_ACEOF
4870 > #define FC_FUNC_(name,NAME) NAME ## __
4871 > _ACEOF
4872 > ;;
4873 >  *)
4874 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4875 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4876 >          ;;
4877 > esac
4878 >
4879 > ac_ext=${FC_SRCEXT-f}
4880 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4881 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4882 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4883 >
4884 >
4885 >
4886 > ac_ext=${FC_SRCEXT-f}
4887 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4888 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4889 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4890 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4891 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4892 > if test "${ac_cv_prog_fc_v+set}" = set; then
4893 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4894 > else
4895 >  cat >conftest.$ac_ext <<_ACEOF
4896 >      program main
4897 >
4898 >      end
4899 > _ACEOF
4900 > rm -f conftest.$ac_objext
4901 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4902 >  (eval $ac_compile) 2>conftest.er1
4903 >  ac_status=$?
4904 >  grep -v '^ *+' conftest.er1 >conftest.err
4905 >  rm -f conftest.er1
4906 >  cat conftest.err >&5
4907 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4908 >  (exit $ac_status); } &&
4909 >         { ac_try='test -z "$ac_fc_werror_flag"
4910 >                         || test ! -s conftest.err'
4911 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4912 >  (eval $ac_try) 2>&5
4913 >  ac_status=$?
4914 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4915 >  (exit $ac_status); }; } &&
4916 >         { ac_try='test -s conftest.$ac_objext'
4917 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4918 >  (eval $ac_try) 2>&5
4919 >  ac_status=$?
4920 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4921 >  (exit $ac_status); }; }; then
4922 >  ac_cv_prog_fc_v=
4923 > # Try some options frequently used verbose output
4924 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4925 >  cat >conftest.$ac_ext <<_ACEOF
4926 >      program main
4927 >
4928 >      end
4929 > _ACEOF
4930 >
4931 > # Compile and link our simple test program by passing a flag (argument
4932 > # 1 to this macro) to the Fortran compiler in order to get
4933 > # "verbose" output that we can then parse for the Fortran linker
4934 > # flags.
4935 > ac_save_FFLAGS=$FCFLAGS
4936 > FCFLAGS="$FCFLAGS $ac_verb"
4937 > (eval echo $as_me:4937: \"$ac_link\") >&5
4938 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4939 > echo "$ac_fc_v_output" >&5
4940 > FCFLAGS=$ac_save_FFLAGS
4941 >
4942 > rm -f conftest*
4943 >
4944 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4945 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4946 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4947 > ac_fc_v_output="`echo $ac_fc_v_output |
4948 >        grep 'LPATH is:' |
4949 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4950 >
4951 > case $ac_fc_v_output in
4952 >  # If we are using xlf then replace all the commas with spaces.
4953 >  *xlfentry*)
4954 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4955 >
4956 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4957 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4958 >  *mGLOB_options_string*)
4959 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4960 >
4961 >  # If we are using Cray Fortran then delete quotes.
4962 >  # Use "\"" instead of '"' for font-lock-mode.
4963 >  # FIXME: a more general fix for quoted arguments with spaces?
4964 >  *cft90*)
4965 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4966 > esac
4967 >
4968 >
4969 >  # look for -l* and *.a constructs in the output
4970 >  for ac_arg in $ac_fc_v_output; do
4971 >     case $ac_arg in
4972 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4973 >          ac_cv_prog_fc_v=$ac_verb
4974 >          break 2 ;;
4975 >     esac
4976 >  done
4977 > done
4978 > if test -z "$ac_cv_prog_fc_v"; then
4979 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4980 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4981 > fi
4982 > else
4983 >  echo "$as_me: failed program was:" >&5
4984 > sed 's/^/| /' conftest.$ac_ext >&5
4985 >
4986 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4987 > echo "$as_me: WARNING: compilation failed" >&2;}
4988 > fi
4989 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4990 >
4991 > fi
4992 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4993 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4994 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4995 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4996 > if test "${ac_cv_fc_libs+set}" = set; then
4997 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4998 > else
4999 >  if test "x$FCLIBS" != "x"; then
5000 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
5001 > else
5002 >
5003 > cat >conftest.$ac_ext <<_ACEOF
5004 >      program main
5005 >
5006 >      end
5007 > _ACEOF
5008 >
5009 > # Compile and link our simple test program by passing a flag (argument
5010 > # 1 to this macro) to the Fortran compiler in order to get
5011 > # "verbose" output that we can then parse for the Fortran linker
5012 > # flags.
5013 > ac_save_FFLAGS=$FCFLAGS
5014 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
5015 > (eval echo $as_me:5015: \"$ac_link\") >&5
5016 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
5017 > echo "$ac_fc_v_output" >&5
5018 > FCFLAGS=$ac_save_FFLAGS
5019 >
5020 > rm -f conftest*
5021 >
5022 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
5023 > # /foo, /bar, and /baz are search directories for the Fortran linker.
5024 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
5025 > ac_fc_v_output="`echo $ac_fc_v_output |
5026 >        grep 'LPATH is:' |
5027 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
5028 >
5029 > case $ac_fc_v_output in
5030 >  # If we are using xlf then replace all the commas with spaces.
5031 >  *xlfentry*)
5032 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
5033 >
5034 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
5035 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
5036 >  *mGLOB_options_string*)
5037 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
5038 >
5039 >  # If we are using Cray Fortran then delete quotes.
5040 >  # Use "\"" instead of '"' for font-lock-mode.
5041 >  # FIXME: a more general fix for quoted arguments with spaces?
5042 >  *cft90*)
5043 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
5044 > esac
5045 >
5046 >
5047 >
5048 > ac_cv_fc_libs=
5049 >
5050 > # Save positional arguments (if any)
5051 > ac_save_positional="$@"
5052 >
5053 > set X $ac_fc_v_output
5054 > while test $# != 1; do
5055 >  shift
5056 >  ac_arg=$1
5057 >  case $ac_arg in
5058 >        [\\/]*.a | ?:[\\/]*.a)
5059 >            ac_exists=false
5060 >  for ac_i in $ac_cv_fc_libs; do
5061 >    if test x"$ac_arg" = x"$ac_i"; then
5062 >      ac_exists=true
5063 >      break
5064 >    fi
5065 >  done
5066 >
5067 >  if test x"$ac_exists" = xtrue; then
5068 >  :
5069 > else
5070 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5071 > fi
5072 >
5073 >          ;;
5074 >        -bI:*)
5075 >            ac_exists=false
5076 >  for ac_i in $ac_cv_fc_libs; do
5077 >    if test x"$ac_arg" = x"$ac_i"; then
5078 >      ac_exists=true
5079 >      break
5080 >    fi
5081 >  done
5082 >
5083 >  if test x"$ac_exists" = xtrue; then
5084 >  :
5085 > else
5086 >  if test "$ac_compiler_gnu" = yes; then
5087 >  for ac_link_opt in $ac_arg; do
5088 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5089 >  done
5090 > else
5091 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5092 > fi
5093 > fi
5094 >
5095 >          ;;
5096 >          # Ignore these flags.
5097 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5098 >          ;;
5099 >        -lkernel32)
5100 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5101 >          ;;
5102 >        -[LRuY])
5103 >          # These flags, when seen by themselves, take an argument.
5104 >          # We remove the space between option and argument and re-iterate
5105 >          # unless we find an empty arg or a new option (starting with -)
5106 >          case $2 in
5107 >             "" | -*);;
5108 >             *)
5109 >                ac_arg="$ac_arg$2"
5110 >                shift; shift
5111 >                set X $ac_arg "$@"
5112 >                ;;
5113 >          esac
5114 >          ;;
5115 >        -YP,*)
5116 >          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5117 >              ac_exists=false
5118 >  for ac_i in $ac_cv_fc_libs; do
5119 >    if test x"$ac_j" = x"$ac_i"; then
5120 >      ac_exists=true
5121 >      break
5122 >    fi
5123 >  done
5124 >
5125 >  if test x"$ac_exists" = xtrue; then
5126 >  :
5127 > else
5128 >  ac_arg="$ac_arg $ac_j"
5129 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5130 > fi
5131 >
5132 >          done
5133 >          ;;
5134 >        -[lLR]*)
5135 >            ac_exists=false
5136 >  for ac_i in $ac_cv_fc_libs; do
5137 >    if test x"$ac_arg" = x"$ac_i"; then
5138 >      ac_exists=true
5139 >      break
5140 >    fi
5141 >  done
5142 >
5143 >  if test x"$ac_exists" = xtrue; then
5144 >  :
5145 > else
5146 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5147 > fi
5148 >
5149 >          ;;
5150 >          # Ignore everything else.
5151 >  esac
5152 > done
5153 > # restore positional arguments
5154 > set X $ac_save_positional; shift
5155 >
5156 > # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5157 > # then we insist that the "run path" must be an absolute path (i.e. it
5158 > # must begin with a "/").
5159 > case `(uname -sr) 2>/dev/null` in
5160 >   "SunOS 5"*)
5161 >      ac_ld_run_path=`echo $ac_fc_v_output |
5162 >                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5163 >      test "x$ac_ld_run_path" != x &&
5164 >        if test "$ac_compiler_gnu" = yes; then
5165 >  for ac_link_opt in $ac_ld_run_path; do
5166 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5167 >  done
5168 > else
5169 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5170 > fi
5171 >      ;;
5172 > esac
5173 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5174 >
5175 > fi
5176 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5177 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
5178 > FCLIBS="$ac_cv_fc_libs"
5179 >
5180 >
5181 > ac_ext=${FC_SRCEXT-f}
5182 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5183 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5184 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5185 >
5186 >
5187 >
5188 > echo "$as_me:$LINENO: checking for module suffix" >&5
5189 > echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5190 > rm -f conftest*
5191 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5192 > rm -f work*
5193 > cat >conftest.$ac_ext <<EOF
5194 >        module conftest
5195 >        integer n
5196 >        parameter (n=1)
5197 >        end module conftest
5198 > EOF
5199 > # SGI and absoft compilers generates module name in upper case!
5200 > testname="conftest"
5201 > modcase="lower"
5202 > if (eval $ac_compile) 2>/dev/null ; then
5203 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5204 >    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5205 >    if test -z "$MOD" ; then
5206 >        MOD=`ls CONFTEST* 2>/dev/null \
5207 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5208 >        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5209 >        if test -n "$MOD" ; then
5210 >            testname="CONFTEST"
5211 >            modcase="upper"
5212 >        fi
5213 >    fi
5214 >    if test -z "$MOD" ; then
5215 >        echo "$as_me:$LINENO: result: unknown" >&5
5216 > echo "${ECHO_T}unknown" >&6
5217 >        # Use mod if we can't figure it out
5218 >        MOD="mod"
5219 >    else
5220 >        echo "$as_me:$LINENO: result: $MOD" >&5
5221 > echo "${ECHO_T}$MOD" >&6
5222 >    fi
5223 >    if test -s work.pcl ; then
5224 >        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
5225 > echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
5226 >    fi
5227 > else
5228 >    echo "$as_me:$LINENO: result: unknown" >&5
5229 > echo "${ECHO_T}unknown" >&6
5230 > fi
5231 >
5232 >
5233 >
5234 >
5235 >
5236 > # Check for module include path (some use -I, some (Solaris) use -M, some
5237 > # (absoft) use -p).
5238 > # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
5239 > # specified, work.pcl and work.pc are created.  However, if you specify
5240 > # a file, it must contain a the name of a file ending in .pc .  Ugh!
5241 > # Use the module made above
5242 > echo "$as_me:$LINENO: checking for module directory path flag" >&5
5243 > echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
5244 > rm -f conftest*
5245 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5246 > rm -f work*
5247 > cat >conftest.$ac_ext <<EOF
5248 >        module conftest
5249 >        integer n
5250 >        parameter (n=1)
5251 >        end module conftest
5252 > EOF
5253 > # SGI and absoft compilers generates module name in upper case!
5254 > testname="conftest"
5255 > if (eval $ac_compile) 2>/dev/null ; then
5256 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5257 >   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5258 >   if test -n "$mod" ; then
5259 >      testname="CONFTEST"
5260 >   fi
5261 >   madedir=0
5262 >   if test ! -d conf ; then mkdir conf ; madedir=1; fi
5263 >   cp $testname.$MOD conf
5264 >   rm -f conftest* CONFTEST*
5265 >   cat >conftest1.$ac_ext <<EOF
5266 >        program main
5267 >        use conftest
5268 >        print *, n
5269 >        end
5270 > EOF
5271 >   F90_WORK_FILES_ARG=""
5272 >   F90MODINCSPEC=""
5273 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5274 >       MODDIRFLAG="-I"
5275 >       F90MODINCSPEC="-I<dir>"
5276 >       echo "$as_me:$LINENO: result: -I" >&5
5277 > echo "${ECHO_T}-I" >&6
5278 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5279 >       MODDIRFLAG="-M"
5280 >       F90MODINCSPEC="-M<dir>"
5281 >       echo "$as_me:$LINENO: result: -M" >&5
5282 > echo "${ECHO_T}-M" >&6
5283 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5284 >       MODDIRFLAG="-p"
5285 >       F90MODINCSPEC="-p<dir>"
5286 >       echo "$as_me:$LINENO: result: -p" >&5
5287 > echo "${ECHO_T}-p" >&6
5288 >   elif test -s work.pc ; then
5289 >        cp work.pc conf/mpimod.pc
5290 >        echo "mpimod.pc" > conf/mpimod.pcl
5291 >        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5292 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5293 >            MODDIRFLAG='-cl,mpimod.pcl'
5294 >            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5295 > echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
5296 >            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
5297 >            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
5298 >
5299 >        else
5300 >            # The version of the Intel compiler that I have refuses to let
5301 >            # you put the "work catalog" list anywhere but the current
5302 >            # directory. For example, you cannot in
5303 >         :
5304 >        fi
5305 >   fi
5306 >   if test -z "MODDIRFLAG" ; then
5307 >       echo "$as_me:$LINENO: result: unknown" >&5
5308 > echo "${ECHO_T}unknown" >&6
5309 >   fi
5310 >
5311 >
5312 >   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
5313 >   if test $madedir = 1 ; then rmdir conf ; fi
5314 > fi
5315 >
5316 >
5317 > echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5318 > echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
5319 > if test "${ac_cv_f90_module_names+set}" = set; then
5320 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5321 > else
5322 >  ac_ext=${FC_SRCEXT-f}
5323 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5324 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5325 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5326 >
5327 > # carry out the test in a new directory, so that we don't miss anything
5328 > mkdir conftest
5329 > cd conftest
5330 > cat >conftest.$ac_ext <<_ACEOF
5331 > MODULE Bar
5332 > END MODULE Bar
5333 > _ACEOF
5334 > rm -f conftest.$ac_objext
5335 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5336 >  (eval $ac_compile) 2>conftest.er1
5337 >  ac_status=$?
5338 >  grep -v '^ *+' conftest.er1 >conftest.err
5339 >  rm -f conftest.er1
5340 >  cat conftest.err >&5
5341 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5342 >  (exit $ac_status); } &&
5343 >         { ac_try='test -z "$ac_fc_werror_flag"
5344 >                         || test ! -s conftest.err'
5345 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5346 >  (eval $ac_try) 2>&5
5347 >  ac_status=$?
5348 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5349 >  (exit $ac_status); }; } &&
5350 >         { ac_try='test -s conftest.$ac_objext'
5351 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5352 >  (eval $ac_try) 2>&5
5353 >  ac_status=$?
5354 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5355 >  (exit $ac_status); }; }; then
5356 >  ac_cv_f90_module_names=
5357 > ac_file_list=*
5358 > for ac_file in $ac_file_list; do
5359 >   case $ac_file in
5360 >      # don't care for original source and object files
5361 >      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
5362 >          :
5363 >          ;;
5364 >      # look for new files derived from the file name
5365 >      *conftest*)
5366 >          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
5367 >            ac_exists=false
5368 >  for ac_i in $ac_cv_f90_module_names; do
5369 >    if test x"$ac_pat" = x"$ac_i"; then
5370 >      ac_exists=true
5371 >      break
5372 >    fi
5373 >  done
5374 >
5375 >  if test x"$ac_exists" = xtrue; then
5376 >  :
5377 > else
5378 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5379 > fi
5380 >
5381 >          ;;
5382 >      # look for new files derived from the module name,
5383 >      # with different case translation schemes
5384 >      *Bar*)
5385 >          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
5386 >            ac_exists=false
5387 >  for ac_i in $ac_cv_f90_module_names; do
5388 >    if test x"$ac_pat" = x"$ac_i"; then
5389 >      ac_exists=true
5390 >      break
5391 >    fi
5392 >  done
5393 >
5394 >  if test x"$ac_exists" = xtrue; then
5395 >  :
5396 > else
5397 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5398 > fi
5399 >
5400 >          ;;
5401 >      *bar*)
5402 >          ac_pat=`echo $ac_file | sed s/bar/%module%/`
5403 >            ac_exists=false
5404 >  for ac_i in $ac_cv_f90_module_names; do
5405 >    if test x"$ac_pat" = x"$ac_i"; then
5406 >      ac_exists=true
5407 >      break
5408 >    fi
5409 >  done
5410 >
5411 >  if test x"$ac_exists" = xtrue; then
5412 >  :
5413 > else
5414 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5415 > fi
5416 >
5417 >          ;;
5418 >      *BAR*)
5419 >          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
5420 >            ac_exists=false
5421 >  for ac_i in $ac_cv_f90_module_names; do
5422 >    if test x"$ac_pat" = x"$ac_i"; then
5423 >      ac_exists=true
5424 >      break
5425 >    fi
5426 >  done
5427 >
5428 >  if test x"$ac_exists" = xtrue; then
5429 >  :
5430 > else
5431 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5432 > fi
5433 >
5434 >          ;;
5435 >       # Other files - we have no idea how they are generated
5436 >       *)
5437 >          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
5438 > echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
5439 >          ;;
5440 >   esac
5441 > done
5442 > if test "x$ac_cv_f90_module_names" = "x"; then
5443 >  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5444 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5445 > fi
5446 >
5447 > else
5448 >  echo "$as_me: failed program was:" >&5
5449 > sed 's/^/| /' conftest.$ac_ext >&5
5450 >
5451 > ac_cv_f90_module_names=
5452 > { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5453 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5454 > fi
5455 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5456 > cd ..
5457 > # cleanup
5458 > rm -rf conftest
5459 > ac_ext=${FC_SRCEXT-f}
5460 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5461 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5462 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5463 >
5464 > fi
5465 > echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
5466 > echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
5467 >
5468 > # We now generate a shell script that will help us to figure out the correct
5469 > # module file names, using the value of ac_cv_f90_module_names
5470 >
5471 > echo "Generating shell script modnam"
5472 >
5473 > cat > scripts/modnam << EOF
5474 > #! /bin/sh
5475 > # This script is auto-generated by configure
5476 > #
5477 > usage="\\
5478 > Usage: \$0 [FILES]
5479 >
5480 > [FILES] are Fortran 90 source files.
5481 > The output is a list of module file names that the Fortran 90 compiler
5482 > generates when compiling [FILES]."
5483 >
5484 > list=
5485 > empty=
5486 >
5487 > if test \$# -eq 0; then
5488 >   echo "\$usage"; exit 0
5489 > fi
5490 >
5491 > while test \$# != 0; do
5492 >
5493 >  file=\$1
5494 >  shift
5495 >
5496 > # strip suffix
5497 >  base=\`echo \$file | sed 's/[.][^.]*$//'\`
5498 >
5499 >  test ! -f \$file && continue
5500 >
5501 > # Look for module definitions and transform them to upper / lower case
5502 >  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/'\`
5503 >  upper=\`echo \$mods | tr a-z A-Z\`
5504 >  lower=\`echo \$mods | tr A-Z a-z\`
5505 >
5506 > # Here, the patterns for generating module file names were inserted by configure
5507 >  for trans in $ac_cv_f90_module_names; do
5508 >
5509 >    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
5510 >    var=empty
5511 >    case \$pat in
5512 >       %MODULE%)
5513 >          var=upper ;;
5514 >       %Module%)
5515 >          var=mods ;;
5516 >       %module%)
5517 >          var=lower ;;
5518 >       %FILE%)
5519 >          test -n "\$mods" && var=base ;;
5520 >    esac
5521 >    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
5522 >    list="\$list \$new"
5523 >  done
5524 > done
5525 >
5526 > echo \$list
5527 > # end of configure-generated script
5528 > EOF
5529 > chmod 755 scripts/modnam
5530 >
5531 > pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
5532 > F90_MODULE_NAMES=empty
5533 > case $pat in
5534 >       %MODULE%)
5535 >          F90_MODULE_NAMES=UPPER ;;
5536 >       %Module%)
5537 >          F90_MODULE_NAMES=Mixed ;;
5538 >       %module%)
5539 >          F90_MODULE_NAMES=lower ;;
5540 >       *)
5541 >          F90_MODULE_NAMES=unknown ;;
5542 > esac
5543 >
5544 > ac_ext=c
5545 > ac_cpp='$CPP $CPPFLAGS'
5546 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5547 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5548 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5549 >
5550 >
5551 > ac_ext=c
5552 > ac_cpp='$CPP $CPPFLAGS'
5553 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5554 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5555 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5556 >
5557 >
5558 >
5559 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5560 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5561 > if test "${ac_cv_lib_m_asin+set}" = set; then
5562 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5563 > else
5564 >  ac_check_lib_save_LIBS=$LIBS
5565 > LIBS="-lm  $LIBS"
5566 > cat >conftest.$ac_ext <<_ACEOF
5567 > /* confdefs.h.  */
5568 > _ACEOF
5569 > cat confdefs.h >>conftest.$ac_ext
5570 > cat >>conftest.$ac_ext <<_ACEOF
5571 > /* end confdefs.h.  */
5572 >
5573 > /* Override any gcc2 internal prototype to avoid an error.  */
5574 > #ifdef __cplusplus
5575 > extern "C"
5576 > #endif
5577 > /* We use char because int might match the return type of a gcc2
5578 >   builtin and then its argument prototype would still apply.  */
5579 > char asin ();
5580 > #ifdef FC_DUMMY_MAIN
5581 > #ifndef FC_DUMMY_MAIN_EQ_F77
5582 > #  ifdef __cplusplus
5583 >     extern "C"
5584 > #  endif
5585 >   int FC_DUMMY_MAIN() { return 1; }
5586 > #endif
5587 > #endif
5588 > int
5589 > main ()
5590 > {
5591 > asin ();
5592 >  ;
5593 >  return 0;
5594 > }
5595 > _ACEOF
5596 > rm -f conftest.$ac_objext conftest$ac_exeext
5597 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5598 >  (eval $ac_link) 2>conftest.er1
5599 >  ac_status=$?
5600 >  grep -v '^ *+' conftest.er1 >conftest.err
5601 >  rm -f conftest.er1
5602 >  cat conftest.err >&5
5603 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5604 >  (exit $ac_status); } &&
5605 >         { ac_try='test -z "$ac_c_werror_flag"
5606 >                         || test ! -s conftest.err'
5607 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5608 >  (eval $ac_try) 2>&5
5609 >  ac_status=$?
5610 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5611 >  (exit $ac_status); }; } &&
5612 >         { ac_try='test -s conftest$ac_exeext'
5613 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5614 >  (eval $ac_try) 2>&5
5615 >  ac_status=$?
5616 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5617 >  (exit $ac_status); }; }; then
5618 >  ac_cv_lib_m_asin=yes
5619 > else
5620 >  echo "$as_me: failed program was:" >&5
5621 > sed 's/^/| /' conftest.$ac_ext >&5
5622 >
5623 > ac_cv_lib_m_asin=no
5624 > fi
5625 > rm -f conftest.err conftest.$ac_objext \
5626 >      conftest$ac_exeext conftest.$ac_ext
5627 > LIBS=$ac_check_lib_save_LIBS
5628 > fi
5629 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5630 > echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5631 > if test $ac_cv_lib_m_asin = yes; then
5632 >  cat >>confdefs.h <<_ACEOF
5633 > #define HAVE_LIBM 1
5634 > _ACEOF
5635 >
5636 >  LIBS="-lm $LIBS"
5637 >
5638 > else
5639 >  exit
5640 > fi
5641 >
5642 >
5643 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5644 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5645 > if test "${ac_cv_header_stdc+set}" = set; then
5646 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5647 > else
5648 >  cat >conftest.$ac_ext <<_ACEOF
5649 > /* confdefs.h.  */
5650 > _ACEOF
5651 > cat confdefs.h >>conftest.$ac_ext
5652 > cat >>conftest.$ac_ext <<_ACEOF
5653 > /* end confdefs.h.  */
5654 > #include <stdlib.h>
5655 > #include <stdarg.h>
5656 > #include <string.h>
5657 > #include <float.h>
5658 >
5659 > #ifdef FC_DUMMY_MAIN
5660 > #ifndef FC_DUMMY_MAIN_EQ_F77
5661 > #  ifdef __cplusplus
5662 >     extern "C"
5663 > #  endif
5664 >   int FC_DUMMY_MAIN() { return 1; }
5665 > #endif
5666 > #endif
5667 > int
5668 > main ()
5669 > {
5670 >
5671 >  ;
5672 >  return 0;
5673 > }
5674 > _ACEOF
5675 > rm -f conftest.$ac_objext
5676 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5677 >  (eval $ac_compile) 2>conftest.er1
5678 >  ac_status=$?
5679 >  grep -v '^ *+' conftest.er1 >conftest.err
5680 >  rm -f conftest.er1
5681 >  cat conftest.err >&5
5682 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5683 >  (exit $ac_status); } &&
5684 >         { ac_try='test -z "$ac_c_werror_flag"
5685 >                         || test ! -s conftest.err'
5686 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5687 >  (eval $ac_try) 2>&5
5688 >  ac_status=$?
5689 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5690 >  (exit $ac_status); }; } &&
5691 >         { ac_try='test -s conftest.$ac_objext'
5692 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5693 >  (eval $ac_try) 2>&5
5694 >  ac_status=$?
5695 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5696 >  (exit $ac_status); }; }; then
5697 >  ac_cv_header_stdc=yes
5698 > else
5699 >  echo "$as_me: failed program was:" >&5
5700 > sed 's/^/| /' conftest.$ac_ext >&5
5701 >
5702 > ac_cv_header_stdc=no
5703 > fi
5704 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5705 >
5706 > if test $ac_cv_header_stdc = yes; then
5707 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5708 >  cat >conftest.$ac_ext <<_ACEOF
5709 > /* confdefs.h.  */
5710 > _ACEOF
5711 > cat confdefs.h >>conftest.$ac_ext
5712 > cat >>conftest.$ac_ext <<_ACEOF
5713 > /* end confdefs.h.  */
5714 > #include <string.h>
5715 >
5716 > _ACEOF
5717 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5718 >  $EGREP "memchr" >/dev/null 2>&1; then
5719 >  :
5720 > else
5721 >  ac_cv_header_stdc=no
5722 > fi
5723 > rm -f conftest*
5724 >
5725 > fi
5726 >
5727 > if test $ac_cv_header_stdc = yes; then
5728 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5729 >  cat >conftest.$ac_ext <<_ACEOF
5730 > /* confdefs.h.  */
5731 > _ACEOF
5732 > cat confdefs.h >>conftest.$ac_ext
5733 > cat >>conftest.$ac_ext <<_ACEOF
5734 > /* end confdefs.h.  */
5735 > #include <stdlib.h>
5736 >
5737 > _ACEOF
5738 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5739 >  $EGREP "free" >/dev/null 2>&1; then
5740 >  :
5741 > else
5742 >  ac_cv_header_stdc=no
5743 > fi
5744 > rm -f conftest*
5745 >
5746 > fi
5747 >
5748 > if test $ac_cv_header_stdc = yes; then
5749 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5750 >  if test "$cross_compiling" = yes; then
5751 >  :
5752 > else
5753 >  cat >conftest.$ac_ext <<_ACEOF
5754 > /* confdefs.h.  */
5755 > _ACEOF
5756 > cat confdefs.h >>conftest.$ac_ext
5757 > cat >>conftest.$ac_ext <<_ACEOF
5758 > /* end confdefs.h.  */
5759 > #include <ctype.h>
5760 > #if ((' ' & 0x0FF) == 0x020)
5761 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5762 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5763 > #else
5764 > # define ISLOWER(c) \
5765 >                   (('a' <= (c) && (c) <= 'i') \
5766 >                     || ('j' <= (c) && (c) <= 'r') \
5767 >                     || ('s' <= (c) && (c) <= 'z'))
5768 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5769 > #endif
5770 >
5771 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5772 > int
5773 > main ()
5774 > {
5775 >  int i;
5776 >  for (i = 0; i < 256; i++)
5777 >    if (XOR (islower (i), ISLOWER (i))
5778 >        || toupper (i) != TOUPPER (i))
5779 >      exit(2);
5780 >  exit (0);
5781 > }
5782 > _ACEOF
5783 > rm -f conftest$ac_exeext
5784 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5785 >  (eval $ac_link) 2>&5
5786 >  ac_status=$?
5787 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5788 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5789 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5790 >  (eval $ac_try) 2>&5
5791 >  ac_status=$?
5792 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5793 >  (exit $ac_status); }; }; then
5794 >  :
5795 > else
5796 >  echo "$as_me: program exited with status $ac_status" >&5
5797 > echo "$as_me: failed program was:" >&5
5798 > sed 's/^/| /' conftest.$ac_ext >&5
5799 >
5800 > ( exit $ac_status )
5801 > ac_cv_header_stdc=no
5802 > fi
5803 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5804 > fi
5805 > fi
5806 > fi
5807 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5808 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
5809 > if test $ac_cv_header_stdc = yes; then
5810 >
5811 > cat >>confdefs.h <<\_ACEOF
5812 > #define STDC_HEADERS 1
5813 > _ACEOF
5814 >
5815 > fi
5816 >
5817 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5818 >
5819 >
5820 >
5821 >
5822 >
5823 >
5824 >
5825 >
5826 >
5827 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5828 >                  inttypes.h stdint.h unistd.h
5829 > do
5830 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5831 > echo "$as_me:$LINENO: checking for $ac_header" >&5
5832 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5833 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
5834 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5835 > else
5836 >  cat >conftest.$ac_ext <<_ACEOF
5837 > /* confdefs.h.  */
5838 > _ACEOF
5839 > cat confdefs.h >>conftest.$ac_ext
5840 > cat >>conftest.$ac_ext <<_ACEOF
5841 > /* end confdefs.h.  */
5842 > $ac_includes_default
5843 >
5844 > #include <$ac_header>
5845 > _ACEOF
5846 > rm -f conftest.$ac_objext
5847 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5848 >  (eval $ac_compile) 2>conftest.er1
5849 >  ac_status=$?
5850 >  grep -v '^ *+' conftest.er1 >conftest.err
5851 >  rm -f conftest.er1
5852 >  cat conftest.err >&5
5853 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5854 >  (exit $ac_status); } &&
5855 >         { ac_try='test -z "$ac_c_werror_flag"
5856 >                         || test ! -s conftest.err'
5857 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5858 >  (eval $ac_try) 2>&5
5859 >  ac_status=$?
5860 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5861 >  (exit $ac_status); }; } &&
5862 >         { ac_try='test -s conftest.$ac_objext'
5863 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5864 >  (eval $ac_try) 2>&5
5865 >  ac_status=$?
5866 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5867 >  (exit $ac_status); }; }; then
5868 >  eval "$as_ac_Header=yes"
5869 > else
5870 >  echo "$as_me: failed program was:" >&5
5871 > sed 's/^/| /' conftest.$ac_ext >&5
5872 >
5873 > eval "$as_ac_Header=no"
5874 > fi
5875 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5876 > fi
5877 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5878 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5879 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
5880 >  cat >>confdefs.h <<_ACEOF
5881 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5882 > _ACEOF
5883 >
5884 > fi
5885 >
5886 > done
5887 >
5888 >
5889 > #
5890 > # Handle user hints
5891 > #
5892 >
5893 > # Check whether --with-zlib or --without-zlib was given.
5894 > if test "${with_zlib+set}" = set; then
5895 >  withval="$with_zlib"
5896 >  zlib_dir="$withval"
5897 > else
5898 >                zlib_dir="not_set"
5899 > fi;
5900 > if test "$zlib_dir" != "no"; then
5901 >
5902 > if test "$zlib_dir" != "not_set" ; then
5903 >  if test -d "$zlib_dir"
5904 >  then
5905 >    ZLIB_HOME="$zlib_dir"
5906 >  else
5907 >    { echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5908 > echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5909 >        ZLIB_HOME=/usr/local
5910 >        if test ! -f "${ZLIB_HOME}/include/zlib.h"
5911 >        then
5912 >                ZLIB_HOME=/usr
5913 >        fi
5914 >  fi
5915 > fi
5916 > #
5917 > # Locate zlib, if wanted
5918 > #
5919 > if test -n "${ZLIB_HOME}"
5920 > then
5921 >        ZLIB_OLD_LDFLAGS=$LDFLAGS
5922 >        ZLIB_OLD_CFLAGS=$CFLAGS
5923 >        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5924 >        CFLAGS="$CFLAGS -I${ZLIB_HOME}/include"
5925 >
5926 >
5927 >        ac_ext=c
5928 > ac_cpp='$CPP $CPPFLAGS'
5929 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5930 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5931 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5932 >
5933 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5934 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5935 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5936 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5937 > else
5938 >  ac_check_lib_save_LIBS=$LIBS
5939 > LIBS="-lz  $LIBS"
5940 > cat >conftest.$ac_ext <<_ACEOF
5941 > /* confdefs.h.  */
5942 > _ACEOF
5943 > cat confdefs.h >>conftest.$ac_ext
5944 > cat >>conftest.$ac_ext <<_ACEOF
5945 > /* end confdefs.h.  */
5946 >
5947 > /* Override any gcc2 internal prototype to avoid an error.  */
5948 > #ifdef __cplusplus
5949 > extern "C"
5950 > #endif
5951 > /* We use char because int might match the return type of a gcc2
5952 >   builtin and then its argument prototype would still apply.  */
5953 > char inflateEnd ();
5954 > #ifdef FC_DUMMY_MAIN
5955 > #ifndef FC_DUMMY_MAIN_EQ_F77
5956 > #  ifdef __cplusplus
5957 >     extern "C"
5958 > #  endif
5959 >   int FC_DUMMY_MAIN() { return 1; }
5960 > #endif
5961 > #endif
5962 > int
5963 > main ()
5964 > {
5965 > inflateEnd ();
5966 >  ;
5967 >  return 0;
5968 > }
5969 > _ACEOF
5970 > rm -f conftest.$ac_objext conftest$ac_exeext
5971 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5972 >  (eval $ac_link) 2>conftest.er1
5973 >  ac_status=$?
5974 >  grep -v '^ *+' conftest.er1 >conftest.err
5975 >  rm -f conftest.er1
5976 >  cat conftest.err >&5
5977 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5978 >  (exit $ac_status); } &&
5979 >         { ac_try='test -z "$ac_c_werror_flag"
5980 >                         || test ! -s conftest.err'
5981 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5982 >  (eval $ac_try) 2>&5
5983 >  ac_status=$?
5984 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5985 >  (exit $ac_status); }; } &&
5986 >         { ac_try='test -s conftest$ac_exeext'
5987 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5988 >  (eval $ac_try) 2>&5
5989 >  ac_status=$?
5990 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5991 >  (exit $ac_status); }; }; then
5992 >  ac_cv_lib_z_inflateEnd=yes
5993 > else
5994 >  echo "$as_me: failed program was:" >&5
5995 > sed 's/^/| /' conftest.$ac_ext >&5
5996 >
5997 > ac_cv_lib_z_inflateEnd=no
5998 > fi
5999 > rm -f conftest.err conftest.$ac_objext \
6000 >      conftest$ac_exeext conftest.$ac_ext
6001 > LIBS=$ac_check_lib_save_LIBS
6002 > fi
6003 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
6004 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
6005 > if test $ac_cv_lib_z_inflateEnd = yes; then
6006 >  zlib_cv_libz=yes
6007 > else
6008 >  zlib_cv_libz=no
6009 > fi
6010 >
6011 >        if test "${ac_cv_header_zlib_h+set}" = set; then
6012 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
6013 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6014 > if test "${ac_cv_header_zlib_h+set}" = set; then
6015 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6016 > fi
6017 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6018 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6019 > else
6020 >  # Is the header compilable?
6021 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
6022 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
6023 > cat >conftest.$ac_ext <<_ACEOF
6024 > /* confdefs.h.  */
6025 > _ACEOF
6026 > cat confdefs.h >>conftest.$ac_ext
6027 > cat >>conftest.$ac_ext <<_ACEOF
6028 > /* end confdefs.h.  */
6029 > $ac_includes_default
6030 > #include <zlib.h>
6031 > _ACEOF
6032 > rm -f conftest.$ac_objext
6033 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6034 >  (eval $ac_compile) 2>conftest.er1
6035 >  ac_status=$?
6036 >  grep -v '^ *+' conftest.er1 >conftest.err
6037 >  rm -f conftest.er1
6038 >  cat conftest.err >&5
6039 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6040 >  (exit $ac_status); } &&
6041 >         { ac_try='test -z "$ac_c_werror_flag"
6042 >                         || test ! -s conftest.err'
6043 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6044 >  (eval $ac_try) 2>&5
6045 >  ac_status=$?
6046 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6047 >  (exit $ac_status); }; } &&
6048 >         { ac_try='test -s conftest.$ac_objext'
6049 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6050 >  (eval $ac_try) 2>&5
6051 >  ac_status=$?
6052 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6053 >  (exit $ac_status); }; }; then
6054 >  ac_header_compiler=yes
6055 > else
6056 >  echo "$as_me: failed program was:" >&5
6057 > sed 's/^/| /' conftest.$ac_ext >&5
6058 >
6059 > ac_header_compiler=no
6060 > fi
6061 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6062 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6063 > echo "${ECHO_T}$ac_header_compiler" >&6
6064 >
6065 > # Is the header present?
6066 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
6067 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
6068 > cat >conftest.$ac_ext <<_ACEOF
6069 > /* confdefs.h.  */
6070 > _ACEOF
6071 > cat confdefs.h >>conftest.$ac_ext
6072 > cat >>conftest.$ac_ext <<_ACEOF
6073 > /* end confdefs.h.  */
6074 > #include <zlib.h>
6075 > _ACEOF
6076 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6077 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6078 >  ac_status=$?
6079 >  grep -v '^ *+' conftest.er1 >conftest.err
6080 >  rm -f conftest.er1
6081 >  cat conftest.err >&5
6082 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6083 >  (exit $ac_status); } >/dev/null; then
6084 >  if test -s conftest.err; then
6085 >    ac_cpp_err=$ac_c_preproc_warn_flag
6086 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6087 >  else
6088 >    ac_cpp_err=
6089 >  fi
6090 > else
6091 >  ac_cpp_err=yes
6092 > fi
6093 > if test -z "$ac_cpp_err"; then
6094 >  ac_header_preproc=yes
6095 > else
6096 >  echo "$as_me: failed program was:" >&5
6097 > sed 's/^/| /' conftest.$ac_ext >&5
6098 >
6099 >  ac_header_preproc=no
6100 > fi
6101 > rm -f conftest.err conftest.$ac_ext
6102 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6103 > echo "${ECHO_T}$ac_header_preproc" >&6
6104 >
6105 > # So?  What about this header?
6106 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6107 >  yes:no: )
6108 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
6109 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6110 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
6111 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
6112 >    ac_header_preproc=yes
6113 >    ;;
6114 >  no:yes:* )
6115 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
6116 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
6117 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
6118 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
6119 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
6120 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
6121 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
6122 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6123 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
6124 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6125 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6126 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6127 >    (
6128 >      cat <<\_ASBOX
6129 > ## ------------------------------ ##
6130 > ## Report this to gezelter@nd.edu ##
6131 > ## ------------------------------ ##
6132 > _ASBOX
6133 >    ) |
6134 >      sed "s/^/$as_me: WARNING:     /" >&2
6135 >    ;;
6136 > esac
6137 > echo "$as_me:$LINENO: checking for zlib.h" >&5
6138 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6139 > if test "${ac_cv_header_zlib_h+set}" = set; then
6140 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6141 > else
6142 >  ac_cv_header_zlib_h=$ac_header_preproc
6143 > fi
6144 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6145 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6146 >
6147 > fi
6148 > if test $ac_cv_header_zlib_h = yes; then
6149 >  zlib_cv_zlib_h=yes
6150 > else
6151 >  zlib_cv_zlib_h=no
6152 > fi
6153 >
6154 >
6155 >        ac_ext=c
6156 > ac_cpp='$CPP $CPPFLAGS'
6157 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6158 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6159 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6160 >
6161 >
6162 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
6163 >
6164 > cat >>confdefs.h <<\_ACEOF
6165 > #define HAVE_ZLIB_H 1
6166 > _ACEOF
6167 >
6168 >
6169 > cat >>confdefs.h <<\_ACEOF
6170 > #define HAVE_LIBZ 1
6171 > _ACEOF
6172 >
6173 >                ZLIB_INC_DIR="${ZLIB_HOME}/include"
6174 >                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
6175 >                ZLIB="-lz"
6176 >        else
6177 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6178 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6179 >                ZLIB_INC_DIR=
6180 >                ZLIB_LIB_DIR=
6181 >                ZLIB=
6182 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6183 >                CFLAGS="$ZLIB_OLD_CFLAGS"
6184 >                echo "$as_me:$LINENO: result: failed" >&5
6185 > echo "${ECHO_T}failed" >&6
6186 >                echo ""
6187 >                echo "*********************************************************"
6188 >                echo "* WARNING: Could not find a working zlib installation   *"
6189 >                echo "* If you need OOPSE to be able to deal with compressed  *"
6190 >                echo "* trajectory dump files be sure to specify a valid zlib *"
6191 >                echo "* installation with --with-zlib=DIR                     *"
6192 >                echo "*                                                       *"
6193 >                echo "* OOPSE will still work without zlib installed.         *"
6194 >                echo "*********************************************************"
6195 >                echo ""
6196 >        fi
6197 >
6198 >
6199 >
6200 > fi
6201 > fi
6202 >
6203 > #
6204 > # Handle user hints
6205 > #
6206 >
6207 > # Check whether --with-fftw or --without-fftw was given.
6208 > if test "${with_fftw+set}" = set; then
6209 >  withval="$with_fftw"
6210 >  fftw_dir="$withval"
6211 > else
6212 >             fftw_dir="not_set"
6213 > fi;
6214 > if test "$fftw_dir" != "no"; then
6215 >  if test "$fftw_dir" != "not_set" ; then
6216 >    if test -d "$fftw_dir"; then
6217 >      FFTW_HOME="$fftw_dir"
6218 >    else
6219 >      { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6220 > echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6221 >      FFTW_HOME=/usr/local
6222 >      if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
6223 >        FFTW_HOME=/usr
6224 >      fi
6225 >    fi
6226 >    #
6227 >    # Locate fftw, if wanted
6228 >    #
6229 >    if test -n "${FFTW_HOME}"; then
6230 >      FFTW_OLD_LDFLAGS=$LDFLAGS
6231 >      FFTW_OLD_CFLAGS=$CFLAGS
6232 >      LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6233 >      CFLAGS="$CFLAGS -I${FFTW_HOME}/include"
6234 >
6235 >
6236 >      ac_ext=c
6237 > ac_cpp='$CPP $CPPFLAGS'
6238 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6239 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6240 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6241 >
6242 >      echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6243 > echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6244 > if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6245 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6246 > else
6247 >  ac_check_lib_save_LIBS=$LIBS
6248 > LIBS="-lfftw3  $LIBS"
6249 > cat >conftest.$ac_ext <<_ACEOF
6250 > /* confdefs.h.  */
6251 > _ACEOF
6252 > cat confdefs.h >>conftest.$ac_ext
6253 > cat >>conftest.$ac_ext <<_ACEOF
6254 > /* end confdefs.h.  */
6255 >
6256 > /* Override any gcc2 internal prototype to avoid an error.  */
6257 > #ifdef __cplusplus
6258 > extern "C"
6259 > #endif
6260 > /* We use char because int might match the return type of a gcc2
6261 >   builtin and then its argument prototype would still apply.  */
6262 > char fftw_execute ();
6263 > #ifdef FC_DUMMY_MAIN
6264 > #ifndef FC_DUMMY_MAIN_EQ_F77
6265 > #  ifdef __cplusplus
6266 >     extern "C"
6267 > #  endif
6268 >   int FC_DUMMY_MAIN() { return 1; }
6269 > #endif
6270 > #endif
6271 > int
6272 > main ()
6273 > {
6274 > fftw_execute ();
6275 >  ;
6276 >  return 0;
6277 > }
6278 > _ACEOF
6279 > rm -f conftest.$ac_objext conftest$ac_exeext
6280 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6281 >  (eval $ac_link) 2>conftest.er1
6282 >  ac_status=$?
6283 >  grep -v '^ *+' conftest.er1 >conftest.err
6284 >  rm -f conftest.er1
6285 >  cat conftest.err >&5
6286 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6287 >  (exit $ac_status); } &&
6288 >         { ac_try='test -z "$ac_c_werror_flag"
6289 >                         || test ! -s conftest.err'
6290 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6291 >  (eval $ac_try) 2>&5
6292 >  ac_status=$?
6293 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6294 >  (exit $ac_status); }; } &&
6295 >         { ac_try='test -s conftest$ac_exeext'
6296 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6297 >  (eval $ac_try) 2>&5
6298 >  ac_status=$?
6299 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6300 >  (exit $ac_status); }; }; then
6301 >  ac_cv_lib_fftw3_fftw_execute=yes
6302 > else
6303 >  echo "$as_me: failed program was:" >&5
6304 > sed 's/^/| /' conftest.$ac_ext >&5
6305 >
6306 > ac_cv_lib_fftw3_fftw_execute=no
6307 > fi
6308 > rm -f conftest.err conftest.$ac_objext \
6309 >      conftest$ac_exeext conftest.$ac_ext
6310 > LIBS=$ac_check_lib_save_LIBS
6311 > fi
6312 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6313 > echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6314 > if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6315 >  fftw_cv_libfftw3=yes
6316 > else
6317 >  fftw_cv_libfftw3=no
6318 > fi
6319 >
6320 >      if test "${ac_cv_header_fftw3_h+set}" = set; then
6321 >  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6322 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6323 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6324 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6325 > fi
6326 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6327 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6328 > else
6329 >  # Is the header compilable?
6330 > echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6331 > echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6332 > cat >conftest.$ac_ext <<_ACEOF
6333 > /* confdefs.h.  */
6334 > _ACEOF
6335 > cat confdefs.h >>conftest.$ac_ext
6336 > cat >>conftest.$ac_ext <<_ACEOF
6337 > /* end confdefs.h.  */
6338 > $ac_includes_default
6339 > #include <fftw3.h>
6340 > _ACEOF
6341 > rm -f conftest.$ac_objext
6342 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6343 >  (eval $ac_compile) 2>conftest.er1
6344 >  ac_status=$?
6345 >  grep -v '^ *+' conftest.er1 >conftest.err
6346 >  rm -f conftest.er1
6347 >  cat conftest.err >&5
6348 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6349 >  (exit $ac_status); } &&
6350 >         { ac_try='test -z "$ac_c_werror_flag"
6351 >                         || test ! -s conftest.err'
6352 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6353 >  (eval $ac_try) 2>&5
6354 >  ac_status=$?
6355 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6356 >  (exit $ac_status); }; } &&
6357 >         { ac_try='test -s conftest.$ac_objext'
6358 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6359 >  (eval $ac_try) 2>&5
6360 >  ac_status=$?
6361 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6362 >  (exit $ac_status); }; }; then
6363 >  ac_header_compiler=yes
6364 > else
6365 >  echo "$as_me: failed program was:" >&5
6366 > sed 's/^/| /' conftest.$ac_ext >&5
6367 >
6368 > ac_header_compiler=no
6369 > fi
6370 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6371 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6372 > echo "${ECHO_T}$ac_header_compiler" >&6
6373 >
6374 > # Is the header present?
6375 > echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6376 > echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6377 > cat >conftest.$ac_ext <<_ACEOF
6378 > /* confdefs.h.  */
6379 > _ACEOF
6380 > cat confdefs.h >>conftest.$ac_ext
6381 > cat >>conftest.$ac_ext <<_ACEOF
6382 > /* end confdefs.h.  */
6383 > #include <fftw3.h>
6384 > _ACEOF
6385 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6386 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6387 >  ac_status=$?
6388 >  grep -v '^ *+' conftest.er1 >conftest.err
6389 >  rm -f conftest.er1
6390 >  cat conftest.err >&5
6391 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6392 >  (exit $ac_status); } >/dev/null; then
6393 >  if test -s conftest.err; then
6394 >    ac_cpp_err=$ac_c_preproc_warn_flag
6395 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6396 >  else
6397 >    ac_cpp_err=
6398 >  fi
6399 > else
6400 >  ac_cpp_err=yes
6401 > fi
6402 > if test -z "$ac_cpp_err"; then
6403 >  ac_header_preproc=yes
6404 > else
6405 >  echo "$as_me: failed program was:" >&5
6406 > sed 's/^/| /' conftest.$ac_ext >&5
6407 >
6408 >  ac_header_preproc=no
6409 > fi
6410 > rm -f conftest.err conftest.$ac_ext
6411 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6412 > echo "${ECHO_T}$ac_header_preproc" >&6
6413 >
6414 > # So?  What about this header?
6415 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6416 >  yes:no: )
6417 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6418 > echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6419 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6420 > echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6421 >    ac_header_preproc=yes
6422 >    ;;
6423 >  no:yes:* )
6424 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6425 > echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6426 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6427 > echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6428 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6429 > echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6430 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6431 > echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6432 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6433 > echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6434 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6435 > echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6436 >    (
6437 >      cat <<\_ASBOX
6438 > ## ------------------------------ ##
6439 > ## Report this to gezelter@nd.edu ##
6440 > ## ------------------------------ ##
6441 > _ASBOX
6442 >    ) |
6443 >      sed "s/^/$as_me: WARNING:     /" >&2
6444 >    ;;
6445 > esac
6446 > echo "$as_me:$LINENO: checking for fftw3.h" >&5
6447 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6448 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6449 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6450 > else
6451 >  ac_cv_header_fftw3_h=$ac_header_preproc
6452 > fi
6453 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6454 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6455 >
6456 > fi
6457 > if test $ac_cv_header_fftw3_h = yes; then
6458 >  fftw_cv_fftw3_h=yes
6459 > else
6460 >  fftw_cv_fftw3_h=no
6461 > fi
6462 >
6463 >
6464 >      if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
6465 >        echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6466 > echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6467 > if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6468 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6469 > else
6470 >  ac_check_lib_save_LIBS=$LIBS
6471 > LIBS="-lfftw  $LIBS"
6472 > cat >conftest.$ac_ext <<_ACEOF
6473 > /* confdefs.h.  */
6474 > _ACEOF
6475 > cat confdefs.h >>conftest.$ac_ext
6476 > cat >>conftest.$ac_ext <<_ACEOF
6477 > /* end confdefs.h.  */
6478 >
6479 > /* Override any gcc2 internal prototype to avoid an error.  */
6480 > #ifdef __cplusplus
6481 > extern "C"
6482 > #endif
6483 > /* We use char because int might match the return type of a gcc2
6484 >   builtin and then its argument prototype would still apply.  */
6485 > char fftwnd_one ();
6486 > #ifdef FC_DUMMY_MAIN
6487 > #ifndef FC_DUMMY_MAIN_EQ_F77
6488 > #  ifdef __cplusplus
6489 >     extern "C"
6490 > #  endif
6491 >   int FC_DUMMY_MAIN() { return 1; }
6492 > #endif
6493 > #endif
6494 > int
6495 > main ()
6496 > {
6497 > fftwnd_one ();
6498 >  ;
6499 >  return 0;
6500 > }
6501 > _ACEOF
6502 > rm -f conftest.$ac_objext conftest$ac_exeext
6503 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6504 >  (eval $ac_link) 2>conftest.er1
6505 >  ac_status=$?
6506 >  grep -v '^ *+' conftest.er1 >conftest.err
6507 >  rm -f conftest.er1
6508 >  cat conftest.err >&5
6509 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6510 >  (exit $ac_status); } &&
6511 >         { ac_try='test -z "$ac_c_werror_flag"
6512 >                         || test ! -s conftest.err'
6513 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6514 >  (eval $ac_try) 2>&5
6515 >  ac_status=$?
6516 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6517 >  (exit $ac_status); }; } &&
6518 >         { ac_try='test -s conftest$ac_exeext'
6519 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6520 >  (eval $ac_try) 2>&5
6521 >  ac_status=$?
6522 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6523 >  (exit $ac_status); }; }; then
6524 >  ac_cv_lib_fftw_fftwnd_one=yes
6525 > else
6526 >  echo "$as_me: failed program was:" >&5
6527 > sed 's/^/| /' conftest.$ac_ext >&5
6528 >
6529 > ac_cv_lib_fftw_fftwnd_one=no
6530 > fi
6531 > rm -f conftest.err conftest.$ac_objext \
6532 >      conftest$ac_exeext conftest.$ac_ext
6533 > LIBS=$ac_check_lib_save_LIBS
6534 > fi
6535 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6536 > echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6537 > if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6538 >  fftw_cv_libfftw=yes
6539 > else
6540 >  fftw_cv_libfftw=no
6541 > fi
6542 >
6543 >        if test "${ac_cv_header_fftw_h+set}" = set; then
6544 >  echo "$as_me:$LINENO: checking for fftw.h" >&5
6545 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6546 > if test "${ac_cv_header_fftw_h+set}" = set; then
6547 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6548 > fi
6549 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6550 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6551 > else
6552 >  # Is the header compilable?
6553 > echo "$as_me:$LINENO: checking fftw.h usability" >&5
6554 > echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6555 > cat >conftest.$ac_ext <<_ACEOF
6556 > /* confdefs.h.  */
6557 > _ACEOF
6558 > cat confdefs.h >>conftest.$ac_ext
6559 > cat >>conftest.$ac_ext <<_ACEOF
6560 > /* end confdefs.h.  */
6561 > $ac_includes_default
6562 > #include <fftw.h>
6563 > _ACEOF
6564 > rm -f conftest.$ac_objext
6565 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6566 >  (eval $ac_compile) 2>conftest.er1
6567 >  ac_status=$?
6568 >  grep -v '^ *+' conftest.er1 >conftest.err
6569 >  rm -f conftest.er1
6570 >  cat conftest.err >&5
6571 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6572 >  (exit $ac_status); } &&
6573 >         { ac_try='test -z "$ac_c_werror_flag"
6574 >                         || test ! -s conftest.err'
6575 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6576 >  (eval $ac_try) 2>&5
6577 >  ac_status=$?
6578 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6579 >  (exit $ac_status); }; } &&
6580 >         { ac_try='test -s conftest.$ac_objext'
6581 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6582 >  (eval $ac_try) 2>&5
6583 >  ac_status=$?
6584 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6585 >  (exit $ac_status); }; }; then
6586 >  ac_header_compiler=yes
6587 > else
6588 >  echo "$as_me: failed program was:" >&5
6589 > sed 's/^/| /' conftest.$ac_ext >&5
6590 >
6591 > ac_header_compiler=no
6592 > fi
6593 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6594 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6595 > echo "${ECHO_T}$ac_header_compiler" >&6
6596 >
6597 > # Is the header present?
6598 > echo "$as_me:$LINENO: checking fftw.h presence" >&5
6599 > echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6600 > cat >conftest.$ac_ext <<_ACEOF
6601 > /* confdefs.h.  */
6602 > _ACEOF
6603 > cat confdefs.h >>conftest.$ac_ext
6604 > cat >>conftest.$ac_ext <<_ACEOF
6605 > /* end confdefs.h.  */
6606 > #include <fftw.h>
6607 > _ACEOF
6608 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6609 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6610 >  ac_status=$?
6611 >  grep -v '^ *+' conftest.er1 >conftest.err
6612 >  rm -f conftest.er1
6613 >  cat conftest.err >&5
6614 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6615 >  (exit $ac_status); } >/dev/null; then
6616 >  if test -s conftest.err; then
6617 >    ac_cpp_err=$ac_c_preproc_warn_flag
6618 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6619 >  else
6620 >    ac_cpp_err=
6621 >  fi
6622 > else
6623 >  ac_cpp_err=yes
6624 > fi
6625 > if test -z "$ac_cpp_err"; then
6626 >  ac_header_preproc=yes
6627 > else
6628 >  echo "$as_me: failed program was:" >&5
6629 > sed 's/^/| /' conftest.$ac_ext >&5
6630 >
6631 >  ac_header_preproc=no
6632 > fi
6633 > rm -f conftest.err conftest.$ac_ext
6634 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6635 > echo "${ECHO_T}$ac_header_preproc" >&6
6636 >
6637 > # So?  What about this header?
6638 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6639 >  yes:no: )
6640 >    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6641 > echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6642 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6643 > echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6644 >    ac_header_preproc=yes
6645 >    ;;
6646 >  no:yes:* )
6647 >    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6648 > echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6649 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6650 > echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6651 >    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6652 > echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6653 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6654 > echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6655 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6656 > echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6657 >    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6658 > echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6659 >    (
6660 >      cat <<\_ASBOX
6661 > ## ------------------------------ ##
6662 > ## Report this to gezelter@nd.edu ##
6663 > ## ------------------------------ ##
6664 > _ASBOX
6665 >    ) |
6666 >      sed "s/^/$as_me: WARNING:     /" >&2
6667 >    ;;
6668 > esac
6669 > echo "$as_me:$LINENO: checking for fftw.h" >&5
6670 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6671 > if test "${ac_cv_header_fftw_h+set}" = set; then
6672 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6673 > else
6674 >  ac_cv_header_fftw_h=$ac_header_preproc
6675 > fi
6676 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6677 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6678 >
6679 > fi
6680 > if test $ac_cv_header_fftw_h = yes; then
6681 >  fftw_cv_fftw_h=yes
6682 > else
6683 >  fftw_cv_fftw_h=no
6684 > fi
6685 >
6686 >
6687 >        if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
6688 >          echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6689 > echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6690 > if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6691 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6692 > else
6693 >  ac_check_lib_save_LIBS=$LIBS
6694 > LIBS="-ldfftw  $LIBS"
6695 > cat >conftest.$ac_ext <<_ACEOF
6696 > /* confdefs.h.  */
6697 > _ACEOF
6698 > cat confdefs.h >>conftest.$ac_ext
6699 > cat >>conftest.$ac_ext <<_ACEOF
6700 > /* end confdefs.h.  */
6701 >
6702 > /* Override any gcc2 internal prototype to avoid an error.  */
6703 > #ifdef __cplusplus
6704 > extern "C"
6705 > #endif
6706 > /* We use char because int might match the return type of a gcc2
6707 >   builtin and then its argument prototype would still apply.  */
6708 > char fftwnd_one ();
6709 > #ifdef FC_DUMMY_MAIN
6710 > #ifndef FC_DUMMY_MAIN_EQ_F77
6711 > #  ifdef __cplusplus
6712 >     extern "C"
6713 > #  endif
6714 >   int FC_DUMMY_MAIN() { return 1; }
6715 > #endif
6716 > #endif
6717 > int
6718 > main ()
6719 > {
6720 > fftwnd_one ();
6721 >  ;
6722 >  return 0;
6723 > }
6724 > _ACEOF
6725 > rm -f conftest.$ac_objext conftest$ac_exeext
6726 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6727 >  (eval $ac_link) 2>conftest.er1
6728 >  ac_status=$?
6729 >  grep -v '^ *+' conftest.er1 >conftest.err
6730 >  rm -f conftest.er1
6731 >  cat conftest.err >&5
6732 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6733 >  (exit $ac_status); } &&
6734 >         { ac_try='test -z "$ac_c_werror_flag"
6735 >                         || test ! -s conftest.err'
6736 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6737 >  (eval $ac_try) 2>&5
6738 >  ac_status=$?
6739 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6740 >  (exit $ac_status); }; } &&
6741 >         { ac_try='test -s conftest$ac_exeext'
6742 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6743 >  (eval $ac_try) 2>&5
6744 >  ac_status=$?
6745 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6746 >  (exit $ac_status); }; }; then
6747 >  ac_cv_lib_dfftw_fftwnd_one=yes
6748 > else
6749 >  echo "$as_me: failed program was:" >&5
6750 > sed 's/^/| /' conftest.$ac_ext >&5
6751 >
6752 > ac_cv_lib_dfftw_fftwnd_one=no
6753 > fi
6754 > rm -f conftest.err conftest.$ac_objext \
6755 >      conftest$ac_exeext conftest.$ac_ext
6756 > LIBS=$ac_check_lib_save_LIBS
6757 > fi
6758 > echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6759 > echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6760 > if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6761 >  fftw_cv_libdfftw=yes
6762 > else
6763 >  fftw_cv_libdfftw=no
6764 > fi
6765 >
6766 >          if test "${ac_cv_header_dfftw_h+set}" = set; then
6767 >  echo "$as_me:$LINENO: checking for dfftw.h" >&5
6768 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6769 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6770 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6771 > fi
6772 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6773 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6774 > else
6775 >  # Is the header compilable?
6776 > echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6777 > echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6778 > cat >conftest.$ac_ext <<_ACEOF
6779 > /* confdefs.h.  */
6780 > _ACEOF
6781 > cat confdefs.h >>conftest.$ac_ext
6782 > cat >>conftest.$ac_ext <<_ACEOF
6783 > /* end confdefs.h.  */
6784 > $ac_includes_default
6785 > #include <dfftw.h>
6786 > _ACEOF
6787 > rm -f conftest.$ac_objext
6788 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6789 >  (eval $ac_compile) 2>conftest.er1
6790 >  ac_status=$?
6791 >  grep -v '^ *+' conftest.er1 >conftest.err
6792 >  rm -f conftest.er1
6793 >  cat conftest.err >&5
6794 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6795 >  (exit $ac_status); } &&
6796 >         { ac_try='test -z "$ac_c_werror_flag"
6797 >                         || test ! -s conftest.err'
6798 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6799 >  (eval $ac_try) 2>&5
6800 >  ac_status=$?
6801 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6802 >  (exit $ac_status); }; } &&
6803 >         { ac_try='test -s conftest.$ac_objext'
6804 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6805 >  (eval $ac_try) 2>&5
6806 >  ac_status=$?
6807 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6808 >  (exit $ac_status); }; }; then
6809 >  ac_header_compiler=yes
6810 > else
6811 >  echo "$as_me: failed program was:" >&5
6812 > sed 's/^/| /' conftest.$ac_ext >&5
6813 >
6814 > ac_header_compiler=no
6815 > fi
6816 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6817 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6818 > echo "${ECHO_T}$ac_header_compiler" >&6
6819 >
6820 > # Is the header present?
6821 > echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6822 > echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6823 > cat >conftest.$ac_ext <<_ACEOF
6824 > /* confdefs.h.  */
6825 > _ACEOF
6826 > cat confdefs.h >>conftest.$ac_ext
6827 > cat >>conftest.$ac_ext <<_ACEOF
6828 > /* end confdefs.h.  */
6829 > #include <dfftw.h>
6830 > _ACEOF
6831 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6832 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6833 >  ac_status=$?
6834 >  grep -v '^ *+' conftest.er1 >conftest.err
6835 >  rm -f conftest.er1
6836 >  cat conftest.err >&5
6837 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6838 >  (exit $ac_status); } >/dev/null; then
6839 >  if test -s conftest.err; then
6840 >    ac_cpp_err=$ac_c_preproc_warn_flag
6841 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6842 >  else
6843 >    ac_cpp_err=
6844 >  fi
6845 > else
6846 >  ac_cpp_err=yes
6847 > fi
6848 > if test -z "$ac_cpp_err"; then
6849 >  ac_header_preproc=yes
6850 > else
6851 >  echo "$as_me: failed program was:" >&5
6852 > sed 's/^/| /' conftest.$ac_ext >&5
6853 >
6854 >  ac_header_preproc=no
6855 > fi
6856 > rm -f conftest.err conftest.$ac_ext
6857 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6858 > echo "${ECHO_T}$ac_header_preproc" >&6
6859 >
6860 > # So?  What about this header?
6861 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6862 >  yes:no: )
6863 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6864 > echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6865 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6866 > echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6867 >    ac_header_preproc=yes
6868 >    ;;
6869 >  no:yes:* )
6870 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6871 > echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6872 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6873 > echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6874 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6875 > echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6876 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6877 > echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6878 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6879 > echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6880 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6881 > echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6882 >    (
6883 >      cat <<\_ASBOX
6884 > ## ------------------------------ ##
6885 > ## Report this to gezelter@nd.edu ##
6886 > ## ------------------------------ ##
6887 > _ASBOX
6888 >    ) |
6889 >      sed "s/^/$as_me: WARNING:     /" >&2
6890 >    ;;
6891 > esac
6892 > echo "$as_me:$LINENO: checking for dfftw.h" >&5
6893 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6894 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6895 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6896 > else
6897 >  ac_cv_header_dfftw_h=$ac_header_preproc
6898 > fi
6899 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6900 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6901 >
6902 > fi
6903 > if test $ac_cv_header_dfftw_h = yes; then
6904 >  fftw_cv_dfftw_h=yes
6905 > else
6906 >  fftw_cv_dfftw_h=no
6907 > fi
6908 >
6909 >
6910 >        fi
6911 >      fi
6912 >      ac_ext=c
6913 > ac_cpp='$CPP $CPPFLAGS'
6914 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6915 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6916 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6917 >
6918 >      if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
6919 >
6920 > cat >>confdefs.h <<\_ACEOF
6921 > #define HAVE_FFTW3_H 1
6922 > _ACEOF
6923 >
6924 >        FFTW_INC_DIR="${FFTW_HOME}/include"
6925 >        FFTW_LIB_DIR="${FFTW_HOME}/lib"
6926 >        FFTW_LIBS="-lfftw3"
6927 >      else
6928 >        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
6929 >
6930 > cat >>confdefs.h <<\_ACEOF
6931 > #define HAVE_FFTW_H 1
6932 > _ACEOF
6933 >
6934 >          FFTW_INC_DIR="${FFTW_HOME}/include"
6935 >          FFTW_LIB_DIR="${FFTW_HOME}/lib"
6936 >          FFTW_LIBS="-lfftw"
6937 >        else
6938 >          if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
6939 >
6940 > cat >>confdefs.h <<\_ACEOF
6941 > #define HAVE_DFFTW_H 1
6942 > _ACEOF
6943 >
6944 >            FFTW_INC_DIR="${FFTW_HOME}/include"
6945 >            FFTW_LIB_DIR="${FFTW_HOME}/lib"
6946 >            FFTW_LIBS="-ldfftw"
6947 >          else
6948 >            echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6949 > echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6950 >            FFTW_INC_DIR=
6951 >            FFTW_LIB_DIR=
6952 >            FFTW_LIBS=
6953 >            LDFLAGS="$FFTW_OLD_LDFLAGS"
6954 >            CFLAGS="$FFTW_OLD_CFLAGS"
6955 >            echo "$as_me:$LINENO: result: failed" >&5
6956 > echo "${ECHO_T}failed" >&6
6957 >            echo ""
6958 >            echo "*********************************************************"
6959 >            echo "* WARNING: Could not find a working FFTW installation   *"
6960 >            echo "* If you need the staticProps program to be able to     *"
6961 >            echo "* compute undulation spectra, be sure to specify a      *"
6962 >            echo "* valid fftw installation with --with-fftw=DIR          *"
6963 >            echo "*                                                       *"
6964 >            echo "* OOPSE will still work without fftw installed.         *"
6965 >            echo "*********************************************************"
6966 >            echo ""
6967 >          fi
6968 >        fi
6969 >      fi
6970 >
6971 >
6972 >
6973 >    fi
6974 >  fi
6975 > fi
6976 >
6977 > #
6978 > # Handle user hints
6979 > #
6980 >
6981 > # Check whether --with-qhull or --without-qhull was given.
6982 > if test "${with_qhull+set}" = set; then
6983 >  withval="$with_qhull"
6984 >  qhull_dir="$withval"
6985 > else
6986 >                qhull_dir="not_set"
6987 > fi;
6988 > if test "$qhull_dir" != "no"; then
6989 >
6990 > if test "$qhull_dir" != "not_set" ; then
6991 >  if test -d "$qhull_dir"
6992 >  then
6993 >    QHULL_HOME="$qhull_dir"
6994 >  else
6995 >    { echo "$as_me:$LINENO: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&5
6996 > echo "$as_me: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&2;}
6997 >        QHULL_HOME=/usr/local
6998 >        if test ! -f "${QHULL_HOME}/include/qhull/qhull.h"
6999 >        then
7000 >                QHULL_HOME=/usr
7001 >        fi
7002 >  fi
7003 > fi
7004 > #
7005 > # Locate qhull, if wanted
7006 > #
7007 > if test -n "${QHULL_HOME}"
7008 > then
7009 >        QHULL_OLD_LDFLAGS=$LDFLAGS
7010 >        QHULL_OLD_CFLAGS=$CFLAGS
7011 >        LDFLAGS="$LDFLAGS -L${QHULL_HOME}/lib"
7012 >        CFLAGS="$CFLAGS -I${QHULL_HOME}/include"
7013 >
7014 >
7015 >        ac_ext=c
7016 > ac_cpp='$CPP $CPPFLAGS'
7017 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7018 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7019 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
7020 >
7021 >        echo "$as_me:$LINENO: checking for qh_qhull in -lqhull" >&5
7022 > echo $ECHO_N "checking for qh_qhull in -lqhull... $ECHO_C" >&6
7023 > if test "${ac_cv_lib_qhull_qh_qhull+set}" = set; then
7024 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7025 > else
7026 >  ac_check_lib_save_LIBS=$LIBS
7027 > LIBS="-lqhull  $LIBS"
7028 > cat >conftest.$ac_ext <<_ACEOF
7029 > /* confdefs.h.  */
7030 > _ACEOF
7031 > cat confdefs.h >>conftest.$ac_ext
7032 > cat >>conftest.$ac_ext <<_ACEOF
7033 > /* end confdefs.h.  */
7034 >
7035 > /* Override any gcc2 internal prototype to avoid an error.  */
7036 > #ifdef __cplusplus
7037 > extern "C"
7038 > #endif
7039 > /* We use char because int might match the return type of a gcc2
7040 >   builtin and then its argument prototype would still apply.  */
7041 > char qh_qhull ();
7042 > #ifdef FC_DUMMY_MAIN
7043 > #ifndef FC_DUMMY_MAIN_EQ_F77
7044 > #  ifdef __cplusplus
7045 >     extern "C"
7046 > #  endif
7047 >   int FC_DUMMY_MAIN() { return 1; }
7048 > #endif
7049 > #endif
7050 > int
7051 > main ()
7052 > {
7053 > qh_qhull ();
7054 >  ;
7055 >  return 0;
7056 > }
7057 > _ACEOF
7058 > rm -f conftest.$ac_objext conftest$ac_exeext
7059 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7060 >  (eval $ac_link) 2>conftest.er1
7061 >  ac_status=$?
7062 >  grep -v '^ *+' conftest.er1 >conftest.err
7063 >  rm -f conftest.er1
7064 >  cat conftest.err >&5
7065 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7066 >  (exit $ac_status); } &&
7067 >         { ac_try='test -z "$ac_c_werror_flag"
7068 >                         || test ! -s conftest.err'
7069 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7070 >  (eval $ac_try) 2>&5
7071 >  ac_status=$?
7072 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7073 >  (exit $ac_status); }; } &&
7074 >         { ac_try='test -s conftest$ac_exeext'
7075 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7076 >  (eval $ac_try) 2>&5
7077 >  ac_status=$?
7078 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7079 >  (exit $ac_status); }; }; then
7080 >  ac_cv_lib_qhull_qh_qhull=yes
7081 > else
7082 >  echo "$as_me: failed program was:" >&5
7083 > sed 's/^/| /' conftest.$ac_ext >&5
7084 >
7085 > ac_cv_lib_qhull_qh_qhull=no
7086 > fi
7087 > rm -f conftest.err conftest.$ac_objext \
7088 >      conftest$ac_exeext conftest.$ac_ext
7089 > LIBS=$ac_check_lib_save_LIBS
7090 > fi
7091 > echo "$as_me:$LINENO: result: $ac_cv_lib_qhull_qh_qhull" >&5
7092 > echo "${ECHO_T}$ac_cv_lib_qhull_qh_qhull" >&6
7093 > if test $ac_cv_lib_qhull_qh_qhull = yes; then
7094 >  qhull_cv_libqhull=yes
7095 > else
7096 >  qhull_cv_libqhull=no
7097 > fi
7098 >
7099 >        if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
7100 >  echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
7101 > echo $ECHO_N "checking for qhull/qhull.h... $ECHO_C" >&6
7102 > if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
7103 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7104 > fi
7105 > echo "$as_me:$LINENO: result: $ac_cv_header_qhull_qhull_h" >&5
7106 > echo "${ECHO_T}$ac_cv_header_qhull_qhull_h" >&6
7107 > else
7108 >  # Is the header compilable?
7109 > echo "$as_me:$LINENO: checking qhull/qhull.h usability" >&5
7110 > echo $ECHO_N "checking qhull/qhull.h usability... $ECHO_C" >&6
7111 > cat >conftest.$ac_ext <<_ACEOF
7112 > /* confdefs.h.  */
7113 > _ACEOF
7114 > cat confdefs.h >>conftest.$ac_ext
7115 > cat >>conftest.$ac_ext <<_ACEOF
7116 > /* end confdefs.h.  */
7117 > $ac_includes_default
7118 > #include <qhull/qhull.h>
7119 > _ACEOF
7120 > rm -f conftest.$ac_objext
7121 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7122 >  (eval $ac_compile) 2>conftest.er1
7123 >  ac_status=$?
7124 >  grep -v '^ *+' conftest.er1 >conftest.err
7125 >  rm -f conftest.er1
7126 >  cat conftest.err >&5
7127 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7128 >  (exit $ac_status); } &&
7129 >         { ac_try='test -z "$ac_c_werror_flag"
7130 >                         || test ! -s conftest.err'
7131 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7132 >  (eval $ac_try) 2>&5
7133 >  ac_status=$?
7134 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7135 >  (exit $ac_status); }; } &&
7136 >         { ac_try='test -s conftest.$ac_objext'
7137 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7138 >  (eval $ac_try) 2>&5
7139 >  ac_status=$?
7140 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7141 >  (exit $ac_status); }; }; then
7142 >  ac_header_compiler=yes
7143 > else
7144 >  echo "$as_me: failed program was:" >&5
7145 > sed 's/^/| /' conftest.$ac_ext >&5
7146 >
7147 > ac_header_compiler=no
7148 > fi
7149 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7150 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7151 > echo "${ECHO_T}$ac_header_compiler" >&6
7152 >
7153 > # Is the header present?
7154 > echo "$as_me:$LINENO: checking qhull/qhull.h presence" >&5
7155 > echo $ECHO_N "checking qhull/qhull.h presence... $ECHO_C" >&6
7156 > cat >conftest.$ac_ext <<_ACEOF
7157 > /* confdefs.h.  */
7158 > _ACEOF
7159 > cat confdefs.h >>conftest.$ac_ext
7160 > cat >>conftest.$ac_ext <<_ACEOF
7161 > /* end confdefs.h.  */
7162 > #include <qhull/qhull.h>
7163 > _ACEOF
7164 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7165 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7166 >  ac_status=$?
7167 >  grep -v '^ *+' conftest.er1 >conftest.err
7168 >  rm -f conftest.er1
7169 >  cat conftest.err >&5
7170 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7171 >  (exit $ac_status); } >/dev/null; then
7172 >  if test -s conftest.err; then
7173 >    ac_cpp_err=$ac_c_preproc_warn_flag
7174 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7175 >  else
7176 >    ac_cpp_err=
7177 >  fi
7178 > else
7179 >  ac_cpp_err=yes
7180 > fi
7181 > if test -z "$ac_cpp_err"; then
7182 >  ac_header_preproc=yes
7183 > else
7184 >  echo "$as_me: failed program was:" >&5
7185 > sed 's/^/| /' conftest.$ac_ext >&5
7186 >
7187 >  ac_header_preproc=no
7188 > fi
7189 > rm -f conftest.err conftest.$ac_ext
7190 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7191 > echo "${ECHO_T}$ac_header_preproc" >&6
7192 >
7193 > # So?  What about this header?
7194 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7195 >  yes:no: )
7196 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: accepted by the compiler, rejected by the preprocessor!" >&5
7197 > echo "$as_me: WARNING: qhull/qhull.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
7198 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: proceeding with the compiler's result" >&5
7199 > echo "$as_me: WARNING: qhull/qhull.h: proceeding with the compiler's result" >&2;}
7200 >    ac_header_preproc=yes
7201 >    ;;
7202 >  no:yes:* )
7203 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: present but cannot be compiled" >&5
7204 > echo "$as_me: WARNING: qhull/qhull.h: present but cannot be compiled" >&2;}
7205 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h:     check for missing prerequisite headers?" >&5
7206 > echo "$as_me: WARNING: qhull/qhull.h:     check for missing prerequisite headers?" >&2;}
7207 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: see the Autoconf documentation" >&5
7208 > echo "$as_me: WARNING: qhull/qhull.h: see the Autoconf documentation" >&2;}
7209 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h:     section \"Present But Cannot Be Compiled\"" >&5
7210 > echo "$as_me: WARNING: qhull/qhull.h:     section \"Present But Cannot Be Compiled\"" >&2;}
7211 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: proceeding with the preprocessor's result" >&5
7212 > echo "$as_me: WARNING: qhull/qhull.h: proceeding with the preprocessor's result" >&2;}
7213 >    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: in the future, the compiler will take precedence" >&5
7214 > echo "$as_me: WARNING: qhull/qhull.h: in the future, the compiler will take precedence" >&2;}
7215 >    (
7216 >      cat <<\_ASBOX
7217 > ## ------------------------------ ##
7218 > ## Report this to gezelter@nd.edu ##
7219 > ## ------------------------------ ##
7220 > _ASBOX
7221 >    ) |
7222 >      sed "s/^/$as_me: WARNING:     /" >&2
7223 >    ;;
7224 > esac
7225 > echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
7226 > echo $ECHO_N "checking for qhull/qhull.h... $ECHO_C" >&6
7227 > if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
7228 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7229 > else
7230 >  ac_cv_header_qhull_qhull_h=$ac_header_preproc
7231 > fi
7232 > echo "$as_me:$LINENO: result: $ac_cv_header_qhull_qhull_h" >&5
7233 > echo "${ECHO_T}$ac_cv_header_qhull_qhull_h" >&6
7234 >
7235 > fi
7236 > if test $ac_cv_header_qhull_qhull_h = yes; then
7237 >  qhull_cv_qhull_h=yes
7238 > else
7239 >  qhull_cv_qhull_h=no
7240 > fi
7241 >
7242 >
7243 >        ac_ext=c
7244 > ac_cpp='$CPP $CPPFLAGS'
7245 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7246 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7247 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
7248 >
7249 >
7250 >        if test "$qhull_cv_libqhull" = "yes" -a "$qhull_cv_qhull_h" = "yes"; then
7251 >
7252 > cat >>confdefs.h <<\_ACEOF
7253 > #define HAVE_QHULL_H 1
7254 > _ACEOF
7255 >
7256 >
7257 > cat >>confdefs.h <<\_ACEOF
7258 > #define HAVE_QHULL 1
7259 > _ACEOF
7260 >
7261 >                USE_QHULL=yes
7262 >                QHULL_INC_DIR="${QHULL_HOME}/include"
7263 >                QHULL_LIB_DIR="${QHULL_HOME}/lib"
7264 >                QHULL="-lqhull"
7265 >        else
7266 >                echo "$as_me:$LINENO: checking qhull in ${QHULL_HOME}" >&5
7267 > echo $ECHO_N "checking qhull in ${QHULL_HOME}... $ECHO_C" >&6
7268 >                QHULL_INC_DIR=
7269 >                QHULL_LIB_DIR=
7270 >                QHULL=
7271 >                USE_QHULL=no
7272 >                LDFLAGS="$QHULL_OLD_LDFLAGS"
7273 >                CFLAGS="$QHULL_OLD_CFLAGS"
7274 >                echo "$as_me:$LINENO: result: failed" >&5
7275 > echo "${ECHO_T}failed" >&6
7276 >                echo ""
7277 >                echo "*********************************************************"
7278 >                echo "* WARNING: Could not find a working qhull installation  *"
7279 >                echo "* If you need OOPSE to be able to deal with convex      *"
7280 >                echo "* hulls be sure to specify a valid qhull installation   *"
7281 >                echo "* with --with-qhull=DIR                                 *"
7282 >                echo "*                                                       *"
7283 >                echo "* OOPSE will still work without qhull installed.        *"
7284 >                echo "*********************************************************"
7285 >                echo ""
7286 >        fi
7287 >
7288 >
7289 >
7290 >
7291 > fi
7292 > fi
7293 >
7294 >
7295 > # Checks for header files.
7296 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
7297 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
7298 > if test "${ac_cv_header_stdc+set}" = set; then
7299 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7300 > else
7301 >  cat >conftest.$ac_ext <<_ACEOF
7302 > /* confdefs.h.  */
7303 > _ACEOF
7304 > cat confdefs.h >>conftest.$ac_ext
7305 > cat >>conftest.$ac_ext <<_ACEOF
7306 > /* end confdefs.h.  */
7307 > #include <stdlib.h>
7308 > #include <stdarg.h>
7309 > #include <string.h>
7310 > #include <float.h>
7311 >
7312 > #ifdef FC_DUMMY_MAIN
7313 > #ifndef FC_DUMMY_MAIN_EQ_F77
7314 > #  ifdef __cplusplus
7315 >     extern "C"
7316 > #  endif
7317 >   int FC_DUMMY_MAIN() { return 1; }
7318 > #endif
7319 > #endif
7320 > int
7321 > main ()
7322 > {
7323 >
7324 >  ;
7325 >  return 0;
7326 > }
7327 > _ACEOF
7328 > rm -f conftest.$ac_objext
7329 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7330 >  (eval $ac_compile) 2>conftest.er1
7331 >  ac_status=$?
7332 >  grep -v '^ *+' conftest.er1 >conftest.err
7333 >  rm -f conftest.er1
7334 >  cat conftest.err >&5
7335 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7336 >  (exit $ac_status); } &&
7337 >         { ac_try='test -z "$ac_c_werror_flag"
7338 >                         || test ! -s conftest.err'
7339 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7340 >  (eval $ac_try) 2>&5
7341 >  ac_status=$?
7342 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7343 >  (exit $ac_status); }; } &&
7344 >         { ac_try='test -s conftest.$ac_objext'
7345 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7346 >  (eval $ac_try) 2>&5
7347 >  ac_status=$?
7348 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7349 >  (exit $ac_status); }; }; then
7350 >  ac_cv_header_stdc=yes
7351 > else
7352 >  echo "$as_me: failed program was:" >&5
7353 > sed 's/^/| /' conftest.$ac_ext >&5
7354 >
7355 > ac_cv_header_stdc=no
7356 > fi
7357 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7358 >
7359 > if test $ac_cv_header_stdc = yes; then
7360 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7361 >  cat >conftest.$ac_ext <<_ACEOF
7362 > /* confdefs.h.  */
7363 > _ACEOF
7364 > cat confdefs.h >>conftest.$ac_ext
7365 > cat >>conftest.$ac_ext <<_ACEOF
7366 > /* end confdefs.h.  */
7367 > #include <string.h>
7368 >
7369 > _ACEOF
7370 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7371 >  $EGREP "memchr" >/dev/null 2>&1; then
7372 >  :
7373 > else
7374 >  ac_cv_header_stdc=no
7375 > fi
7376 > rm -f conftest*
7377 >
7378 > fi
7379 >
7380 > if test $ac_cv_header_stdc = yes; then
7381 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7382 >  cat >conftest.$ac_ext <<_ACEOF
7383 > /* confdefs.h.  */
7384 > _ACEOF
7385 > cat confdefs.h >>conftest.$ac_ext
7386 > cat >>conftest.$ac_ext <<_ACEOF
7387 > /* end confdefs.h.  */
7388 > #include <stdlib.h>
7389 >
7390 > _ACEOF
7391 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7392 >  $EGREP "free" >/dev/null 2>&1; then
7393 >  :
7394 > else
7395 >  ac_cv_header_stdc=no
7396 > fi
7397 > rm -f conftest*
7398 >
7399 > fi
7400 >
7401 > if test $ac_cv_header_stdc = yes; then
7402 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7403 >  if test "$cross_compiling" = yes; then
7404 >  :
7405 > else
7406 >  cat >conftest.$ac_ext <<_ACEOF
7407 > /* confdefs.h.  */
7408 > _ACEOF
7409 > cat confdefs.h >>conftest.$ac_ext
7410 > cat >>conftest.$ac_ext <<_ACEOF
7411 > /* end confdefs.h.  */
7412 > #include <ctype.h>
7413 > #if ((' ' & 0x0FF) == 0x020)
7414 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7415 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7416 > #else
7417 > # define ISLOWER(c) \
7418 >                   (('a' <= (c) && (c) <= 'i') \
7419 >                     || ('j' <= (c) && (c) <= 'r') \
7420 >                     || ('s' <= (c) && (c) <= 'z'))
7421 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7422 > #endif
7423 >
7424 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7425 > int
7426 > main ()
7427 > {
7428 >  int i;
7429 >  for (i = 0; i < 256; i++)
7430 >    if (XOR (islower (i), ISLOWER (i))
7431 >        || toupper (i) != TOUPPER (i))
7432 >      exit(2);
7433 >  exit (0);
7434 > }
7435 > _ACEOF
7436 > rm -f conftest$ac_exeext
7437 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7438 >  (eval $ac_link) 2>&5
7439 >  ac_status=$?
7440 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7441 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7442 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7443 >  (eval $ac_try) 2>&5
7444 >  ac_status=$?
7445 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7446 >  (exit $ac_status); }; }; then
7447 >  :
7448 > else
7449 >  echo "$as_me: program exited with status $ac_status" >&5
7450 > echo "$as_me: failed program was:" >&5
7451 > sed 's/^/| /' conftest.$ac_ext >&5
7452 >
7453 > ( exit $ac_status )
7454 > ac_cv_header_stdc=no
7455 > fi
7456 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7457 > fi
7458 > fi
7459 > fi
7460 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7461 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7462 > if test $ac_cv_header_stdc = yes; then
7463 >
7464 > cat >>confdefs.h <<\_ACEOF
7465 > #define STDC_HEADERS 1
7466 > _ACEOF
7467 >
7468 > fi
7469 >
7470 >
7471 >
7472 >
7473 >
7474 >
7475 >
7476 >
7477 >
7478 >
7479 >
7480 >
7481 >
7482 >
7483 >
7484 >
7485 >
7486 >
7487 >
7488 >
7489 >
7490 >
7491 >
7492 >
7493 >
7494 >
7495 > 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
7496 > do
7497 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7498 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7499 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7500 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7501 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7502 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7503 > fi
7504 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7505 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7506 > else
7507 >  # Is the header compilable?
7508 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7509 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7510 > cat >conftest.$ac_ext <<_ACEOF
7511 > /* confdefs.h.  */
7512 > _ACEOF
7513 > cat confdefs.h >>conftest.$ac_ext
7514 > cat >>conftest.$ac_ext <<_ACEOF
7515 > /* end confdefs.h.  */
7516 > $ac_includes_default
7517 > #include <$ac_header>
7518 > _ACEOF
7519 > rm -f conftest.$ac_objext
7520 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7521 >  (eval $ac_compile) 2>conftest.er1
7522 >  ac_status=$?
7523 >  grep -v '^ *+' conftest.er1 >conftest.err
7524 >  rm -f conftest.er1
7525 >  cat conftest.err >&5
7526 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7527 >  (exit $ac_status); } &&
7528 >         { ac_try='test -z "$ac_c_werror_flag"
7529 >                         || test ! -s conftest.err'
7530 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7531 >  (eval $ac_try) 2>&5
7532 >  ac_status=$?
7533 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7534 >  (exit $ac_status); }; } &&
7535 >         { ac_try='test -s conftest.$ac_objext'
7536 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7537 >  (eval $ac_try) 2>&5
7538 >  ac_status=$?
7539 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7540 >  (exit $ac_status); }; }; then
7541 >  ac_header_compiler=yes
7542 > else
7543 >  echo "$as_me: failed program was:" >&5
7544 > sed 's/^/| /' conftest.$ac_ext >&5
7545 >
7546 > ac_header_compiler=no
7547 > fi
7548 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7549 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7550 > echo "${ECHO_T}$ac_header_compiler" >&6
7551 >
7552 > # Is the header present?
7553 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7554 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7555 > cat >conftest.$ac_ext <<_ACEOF
7556 > /* confdefs.h.  */
7557 > _ACEOF
7558 > cat confdefs.h >>conftest.$ac_ext
7559 > cat >>conftest.$ac_ext <<_ACEOF
7560 > /* end confdefs.h.  */
7561 > #include <$ac_header>
7562 > _ACEOF
7563 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7564 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7565 >  ac_status=$?
7566 >  grep -v '^ *+' conftest.er1 >conftest.err
7567 >  rm -f conftest.er1
7568 >  cat conftest.err >&5
7569 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7570 >  (exit $ac_status); } >/dev/null; then
7571 >  if test -s conftest.err; then
7572 >    ac_cpp_err=$ac_c_preproc_warn_flag
7573 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7574 >  else
7575 >    ac_cpp_err=
7576 >  fi
7577 > else
7578 >  ac_cpp_err=yes
7579 > fi
7580 > if test -z "$ac_cpp_err"; then
7581 >  ac_header_preproc=yes
7582 > else
7583 >  echo "$as_me: failed program was:" >&5
7584 > sed 's/^/| /' conftest.$ac_ext >&5
7585 >
7586 >  ac_header_preproc=no
7587 > fi
7588 > rm -f conftest.err conftest.$ac_ext
7589 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7590 > echo "${ECHO_T}$ac_header_preproc" >&6
7591 >
7592 > # So?  What about this header?
7593 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7594 >  yes:no: )
7595 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7596 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7597 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7598 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7599 >    ac_header_preproc=yes
7600 >    ;;
7601 >  no:yes:* )
7602 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7603 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7604 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7605 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7606 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7607 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7608 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7609 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7610 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7611 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7612 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7613 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7614 >    (
7615 >      cat <<\_ASBOX
7616 > ## ------------------------------ ##
7617 > ## Report this to gezelter@nd.edu ##
7618 > ## ------------------------------ ##
7619 > _ASBOX
7620 >    ) |
7621 >      sed "s/^/$as_me: WARNING:     /" >&2
7622 >    ;;
7623 > esac
7624 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7625 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7626 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7627 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7628 > else
7629 >  eval "$as_ac_Header=\$ac_header_preproc"
7630 > fi
7631 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7632 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7633 >
7634 > fi
7635 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7636 >  cat >>confdefs.h <<_ACEOF
7637 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7638 > _ACEOF
7639 >
7640 > fi
7641 >
7642 > done
7643 >
7644 >
7645 > # Checks for typedefs, structures, and compiler characteristics.
7646 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7647 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7648 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7649 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7650 > else
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 >
7658 > #include <stdbool.h>
7659 > #ifndef bool
7660 > # error bool is not defined
7661 > #endif
7662 > #ifndef false
7663 > # error false is not defined
7664 > #endif
7665 > #if false
7666 > # error false is not 0
7667 > #endif
7668 > #ifndef true
7669 > # error true is not defined
7670 > #endif
7671 > #if true != 1
7672 > # error true is not 1
7673 > #endif
7674 > #ifndef __bool_true_false_are_defined
7675 > # error __bool_true_false_are_defined is not defined
7676 > #endif
7677 >
7678 >        struct s { _Bool s: 1; _Bool t; } s;
7679 >
7680 >        char a[true == 1 ? 1 : -1];
7681 >        char b[false == 0 ? 1 : -1];
7682 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7683 >        char d[(bool) -0.5 == true ? 1 : -1];
7684 >        bool e = &s;
7685 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7686 >        char g[true];
7687 >        char h[sizeof (_Bool)];
7688 >        char i[sizeof s.t];
7689 >
7690 > #ifdef FC_DUMMY_MAIN
7691 > #ifndef FC_DUMMY_MAIN_EQ_F77
7692 > #  ifdef __cplusplus
7693 >     extern "C"
7694 > #  endif
7695 >   int FC_DUMMY_MAIN() { return 1; }
7696 > #endif
7697 > #endif
7698 > int
7699 > main ()
7700 > {
7701 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7702 >  ;
7703 >  return 0;
7704 > }
7705 > _ACEOF
7706 > rm -f conftest.$ac_objext
7707 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7708 >  (eval $ac_compile) 2>conftest.er1
7709 >  ac_status=$?
7710 >  grep -v '^ *+' conftest.er1 >conftest.err
7711 >  rm -f conftest.er1
7712 >  cat conftest.err >&5
7713 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7714 >  (exit $ac_status); } &&
7715 >         { ac_try='test -z "$ac_c_werror_flag"
7716 >                         || test ! -s conftest.err'
7717 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7718 >  (eval $ac_try) 2>&5
7719 >  ac_status=$?
7720 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7721 >  (exit $ac_status); }; } &&
7722 >         { ac_try='test -s conftest.$ac_objext'
7723 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7724 >  (eval $ac_try) 2>&5
7725 >  ac_status=$?
7726 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7727 >  (exit $ac_status); }; }; then
7728 >  ac_cv_header_stdbool_h=yes
7729 > else
7730 >  echo "$as_me: failed program was:" >&5
7731 > sed 's/^/| /' conftest.$ac_ext >&5
7732 >
7733 > ac_cv_header_stdbool_h=no
7734 > fi
7735 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7736 > fi
7737 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7738 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7739 > echo "$as_me:$LINENO: checking for _Bool" >&5
7740 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7741 > if test "${ac_cv_type__Bool+set}" = set; then
7742 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7743 > else
7744 >  cat >conftest.$ac_ext <<_ACEOF
7745 > /* confdefs.h.  */
7746 > _ACEOF
7747 > cat confdefs.h >>conftest.$ac_ext
7748 > cat >>conftest.$ac_ext <<_ACEOF
7749 > /* end confdefs.h.  */
7750 > $ac_includes_default
7751 > #ifdef FC_DUMMY_MAIN
7752 > #ifndef FC_DUMMY_MAIN_EQ_F77
7753 > #  ifdef __cplusplus
7754 >     extern "C"
7755 > #  endif
7756 >   int FC_DUMMY_MAIN() { return 1; }
7757 > #endif
7758 > #endif
7759 > int
7760 > main ()
7761 > {
7762 > if ((_Bool *) 0)
7763 >  return 0;
7764 > if (sizeof (_Bool))
7765 >  return 0;
7766 >  ;
7767 >  return 0;
7768 > }
7769 > _ACEOF
7770 > rm -f conftest.$ac_objext
7771 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7772 >  (eval $ac_compile) 2>conftest.er1
7773 >  ac_status=$?
7774 >  grep -v '^ *+' conftest.er1 >conftest.err
7775 >  rm -f conftest.er1
7776 >  cat conftest.err >&5
7777 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7778 >  (exit $ac_status); } &&
7779 >         { ac_try='test -z "$ac_c_werror_flag"
7780 >                         || test ! -s conftest.err'
7781 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7782 >  (eval $ac_try) 2>&5
7783 >  ac_status=$?
7784 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7785 >  (exit $ac_status); }; } &&
7786 >         { ac_try='test -s conftest.$ac_objext'
7787 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7788 >  (eval $ac_try) 2>&5
7789 >  ac_status=$?
7790 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7791 >  (exit $ac_status); }; }; then
7792 >  ac_cv_type__Bool=yes
7793 > else
7794 >  echo "$as_me: failed program was:" >&5
7795 > sed 's/^/| /' conftest.$ac_ext >&5
7796 >
7797 > ac_cv_type__Bool=no
7798 > fi
7799 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7800 > fi
7801 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7802 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7803 > if test $ac_cv_type__Bool = yes; then
7804 >
7805 > cat >>confdefs.h <<_ACEOF
7806 > #define HAVE__BOOL 1
7807 > _ACEOF
7808 >
7809 >
7810 > fi
7811 >
7812 > if test $ac_cv_header_stdbool_h = yes; then
7813 >
7814 > cat >>confdefs.h <<\_ACEOF
7815 > #define HAVE_STDBOOL_H 1
7816 > _ACEOF
7817 >
7818 > fi
7819 >
7820 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7821 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7822 > if test "${ac_cv_c_const+set}" = set; then
7823 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7824 > else
7825 >  cat >conftest.$ac_ext <<_ACEOF
7826 > /* confdefs.h.  */
7827 > _ACEOF
7828 > cat confdefs.h >>conftest.$ac_ext
7829 > cat >>conftest.$ac_ext <<_ACEOF
7830 > /* end confdefs.h.  */
7831 >
7832 > #ifdef FC_DUMMY_MAIN
7833 > #ifndef FC_DUMMY_MAIN_EQ_F77
7834 > #  ifdef __cplusplus
7835 >     extern "C"
7836 > #  endif
7837 >   int FC_DUMMY_MAIN() { return 1; }
7838 > #endif
7839 > #endif
7840 > int
7841 > main ()
7842 > {
7843 > /* FIXME: Include the comments suggested by Paul. */
7844 > #ifndef __cplusplus
7845 >  /* Ultrix mips cc rejects this.  */
7846 >  typedef int charset[2];
7847 >  const charset x;
7848 >  /* SunOS 4.1.1 cc rejects this.  */
7849 >  char const *const *ccp;
7850 >  char **p;
7851 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7852 >  struct point {int x, y;};
7853 >  static struct point const zero = {0,0};
7854 >  /* AIX XL C 1.02.0.0 rejects this.
7855 >     It does not let you subtract one const X* pointer from another in
7856 >     an arm of an if-expression whose if-part is not a constant
7857 >     expression */
7858 >  const char *g = "string";
7859 >  ccp = &g + (g ? g-g : 0);
7860 >  /* HPUX 7.0 cc rejects these. */
7861 >  ++ccp;
7862 >  p = (char**) ccp;
7863 >  ccp = (char const *const *) p;
7864 >  { /* SCO 3.2v4 cc rejects this.  */
7865 >    char *t;
7866 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7867 >
7868 >    *t++ = 0;
7869 >  }
7870 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7871 >    int x[] = {25, 17};
7872 >    const int *foo = &x[0];
7873 >    ++foo;
7874 >  }
7875 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7876 >    typedef const int *iptr;
7877 >    iptr p = 0;
7878 >    ++p;
7879 >  }
7880 >  { /* AIX XL C 1.02.0.0 rejects this saying
7881 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7882 >    struct s { int j; const int *ap[3]; };
7883 >    struct s *b; b->j = 5;
7884 >  }
7885 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7886 >    const int foo = 10;
7887 >  }
7888 > #endif
7889 >
7890 >  ;
7891 >  return 0;
7892 > }
7893 > _ACEOF
7894 > rm -f conftest.$ac_objext
7895 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7896 >  (eval $ac_compile) 2>conftest.er1
7897 >  ac_status=$?
7898 >  grep -v '^ *+' conftest.er1 >conftest.err
7899 >  rm -f conftest.er1
7900 >  cat conftest.err >&5
7901 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7902 >  (exit $ac_status); } &&
7903 >         { ac_try='test -z "$ac_c_werror_flag"
7904 >                         || test ! -s conftest.err'
7905 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7906 >  (eval $ac_try) 2>&5
7907 >  ac_status=$?
7908 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7909 >  (exit $ac_status); }; } &&
7910 >         { ac_try='test -s conftest.$ac_objext'
7911 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7912 >  (eval $ac_try) 2>&5
7913 >  ac_status=$?
7914 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7915 >  (exit $ac_status); }; }; then
7916 >  ac_cv_c_const=yes
7917 > else
7918 >  echo "$as_me: failed program was:" >&5
7919 > sed 's/^/| /' conftest.$ac_ext >&5
7920 >
7921 > ac_cv_c_const=no
7922 > fi
7923 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7924 > fi
7925 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7926 > echo "${ECHO_T}$ac_cv_c_const" >&6
7927 > if test $ac_cv_c_const = no; then
7928 >
7929 > cat >>confdefs.h <<\_ACEOF
7930 > #define const
7931 > _ACEOF
7932 >
7933 > fi
7934 >
7935 > echo "$as_me:$LINENO: checking for inline" >&5
7936 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7937 > if test "${ac_cv_c_inline+set}" = set; then
7938 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7939 > else
7940 >  ac_cv_c_inline=no
7941 > for ac_kw in inline __inline__ __inline; do
7942 >  cat >conftest.$ac_ext <<_ACEOF
7943 > /* confdefs.h.  */
7944 > _ACEOF
7945 > cat confdefs.h >>conftest.$ac_ext
7946 > cat >>conftest.$ac_ext <<_ACEOF
7947 > /* end confdefs.h.  */
7948 > #ifndef __cplusplus
7949 > typedef int foo_t;
7950 > static $ac_kw foo_t static_foo () {return 0; }
7951 > $ac_kw foo_t foo () {return 0; }
7952 > #endif
7953 >
7954 > _ACEOF
7955 > rm -f conftest.$ac_objext
7956 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7957 >  (eval $ac_compile) 2>conftest.er1
7958 >  ac_status=$?
7959 >  grep -v '^ *+' conftest.er1 >conftest.err
7960 >  rm -f conftest.er1
7961 >  cat conftest.err >&5
7962 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7963 >  (exit $ac_status); } &&
7964 >         { ac_try='test -z "$ac_c_werror_flag"
7965 >                         || test ! -s conftest.err'
7966 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7967 >  (eval $ac_try) 2>&5
7968 >  ac_status=$?
7969 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7970 >  (exit $ac_status); }; } &&
7971 >         { ac_try='test -s conftest.$ac_objext'
7972 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7973 >  (eval $ac_try) 2>&5
7974 >  ac_status=$?
7975 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7976 >  (exit $ac_status); }; }; then
7977 >  ac_cv_c_inline=$ac_kw; break
7978 > else
7979 >  echo "$as_me: failed program was:" >&5
7980 > sed 's/^/| /' conftest.$ac_ext >&5
7981 >
7982 > fi
7983 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7984 > done
7985 >
7986 > fi
7987 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7988 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7989 >
7990 >
7991 > case $ac_cv_c_inline in
7992 >  inline | yes) ;;
7993 >  *)
7994 >    case $ac_cv_c_inline in
7995 >      no) ac_val=;;
7996 >      *) ac_val=$ac_cv_c_inline;;
7997 >    esac
7998 >    cat >>confdefs.h <<_ACEOF
7999 > #ifndef __cplusplus
8000 > #define inline $ac_val
8001 > #endif
8002 > _ACEOF
8003 >    ;;
8004 > esac
8005 >
8006 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
8007 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
8008 > if test "${ac_cv_c_restrict+set}" = set; then
8009 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8010 > else
8011 >  ac_cv_c_restrict=no
8012 >   # Try the official restrict keyword, then gcc's __restrict, and
8013 >   # the less common variants.
8014 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
8015 >     cat >conftest.$ac_ext <<_ACEOF
8016 > /* confdefs.h.  */
8017 > _ACEOF
8018 > cat confdefs.h >>conftest.$ac_ext
8019 > cat >>conftest.$ac_ext <<_ACEOF
8020 > /* end confdefs.h.  */
8021 > float * $ac_kw x;
8022 > _ACEOF
8023 > rm -f conftest.$ac_objext
8024 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8025 >  (eval $ac_compile) 2>conftest.er1
8026 >  ac_status=$?
8027 >  grep -v '^ *+' conftest.er1 >conftest.err
8028 >  rm -f conftest.er1
8029 >  cat conftest.err >&5
8030 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8031 >  (exit $ac_status); } &&
8032 >         { ac_try='test -z "$ac_c_werror_flag"
8033 >                         || test ! -s conftest.err'
8034 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8035 >  (eval $ac_try) 2>&5
8036 >  ac_status=$?
8037 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8038 >  (exit $ac_status); }; } &&
8039 >         { ac_try='test -s conftest.$ac_objext'
8040 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8041 >  (eval $ac_try) 2>&5
8042 >  ac_status=$?
8043 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8044 >  (exit $ac_status); }; }; then
8045 >  ac_cv_c_restrict=$ac_kw; break
8046 > else
8047 >  echo "$as_me: failed program was:" >&5
8048 > sed 's/^/| /' conftest.$ac_ext >&5
8049 >
8050 > fi
8051 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8052 >   done
8053 >
8054 > fi
8055 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
8056 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
8057 > case $ac_cv_c_restrict in
8058 >   restrict) ;;
8059 >   no)
8060 > cat >>confdefs.h <<\_ACEOF
8061 > #define restrict
8062 > _ACEOF
8063 > ;;
8064 >   *)  cat >>confdefs.h <<_ACEOF
8065 > #define restrict $ac_cv_c_restrict
8066 > _ACEOF
8067 > ;;
8068 > esac
8069 >
8070 > echo "$as_me:$LINENO: checking for size_t" >&5
8071 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
8072 > if test "${ac_cv_type_size_t+set}" = set; then
8073 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8074 > else
8075 >  cat >conftest.$ac_ext <<_ACEOF
8076 > /* confdefs.h.  */
8077 > _ACEOF
8078 > cat confdefs.h >>conftest.$ac_ext
8079 > cat >>conftest.$ac_ext <<_ACEOF
8080 > /* end confdefs.h.  */
8081 > $ac_includes_default
8082 > #ifdef FC_DUMMY_MAIN
8083 > #ifndef FC_DUMMY_MAIN_EQ_F77
8084 > #  ifdef __cplusplus
8085 >     extern "C"
8086 > #  endif
8087 >   int FC_DUMMY_MAIN() { return 1; }
8088 > #endif
8089 > #endif
8090 > int
8091 > main ()
8092 > {
8093 > if ((size_t *) 0)
8094 >  return 0;
8095 > if (sizeof (size_t))
8096 >  return 0;
8097 >  ;
8098 >  return 0;
8099 > }
8100 > _ACEOF
8101 > rm -f conftest.$ac_objext
8102 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8103 >  (eval $ac_compile) 2>conftest.er1
8104 >  ac_status=$?
8105 >  grep -v '^ *+' conftest.er1 >conftest.err
8106 >  rm -f conftest.er1
8107 >  cat conftest.err >&5
8108 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8109 >  (exit $ac_status); } &&
8110 >         { ac_try='test -z "$ac_c_werror_flag"
8111 >                         || test ! -s conftest.err'
8112 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8113 >  (eval $ac_try) 2>&5
8114 >  ac_status=$?
8115 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8116 >  (exit $ac_status); }; } &&
8117 >         { ac_try='test -s conftest.$ac_objext'
8118 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8119 >  (eval $ac_try) 2>&5
8120 >  ac_status=$?
8121 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8122 >  (exit $ac_status); }; }; then
8123 >  ac_cv_type_size_t=yes
8124 > else
8125 >  echo "$as_me: failed program was:" >&5
8126 > sed 's/^/| /' conftest.$ac_ext >&5
8127 >
8128 > ac_cv_type_size_t=no
8129 > fi
8130 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8131 > fi
8132 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
8133 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
8134 > if test $ac_cv_type_size_t = yes; then
8135 >  :
8136 > else
8137 >
8138 > cat >>confdefs.h <<_ACEOF
8139 > #define size_t unsigned
8140 > _ACEOF
8141 >
8142 > fi
8143 >
8144 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
8145 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
8146 > if test "${ac_cv_header_time+set}" = set; then
8147 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8148 > else
8149 >  cat >conftest.$ac_ext <<_ACEOF
8150 > /* confdefs.h.  */
8151 > _ACEOF
8152 > cat confdefs.h >>conftest.$ac_ext
8153 > cat >>conftest.$ac_ext <<_ACEOF
8154 > /* end confdefs.h.  */
8155 > #include <sys/types.h>
8156 > #include <sys/time.h>
8157 > #include <time.h>
8158 >
8159 > #ifdef FC_DUMMY_MAIN
8160 > #ifndef FC_DUMMY_MAIN_EQ_F77
8161 > #  ifdef __cplusplus
8162 >     extern "C"
8163 > #  endif
8164 >   int FC_DUMMY_MAIN() { return 1; }
8165 > #endif
8166 > #endif
8167 > int
8168 > main ()
8169 > {
8170 > if ((struct tm *) 0)
8171 > return 0;
8172 >  ;
8173 >  return 0;
8174 > }
8175 > _ACEOF
8176 > rm -f conftest.$ac_objext
8177 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8178 >  (eval $ac_compile) 2>conftest.er1
8179 >  ac_status=$?
8180 >  grep -v '^ *+' conftest.er1 >conftest.err
8181 >  rm -f conftest.er1
8182 >  cat conftest.err >&5
8183 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8184 >  (exit $ac_status); } &&
8185 >         { ac_try='test -z "$ac_c_werror_flag"
8186 >                         || test ! -s conftest.err'
8187 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8188 >  (eval $ac_try) 2>&5
8189 >  ac_status=$?
8190 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8191 >  (exit $ac_status); }; } &&
8192 >         { ac_try='test -s conftest.$ac_objext'
8193 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8194 >  (eval $ac_try) 2>&5
8195 >  ac_status=$?
8196 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8197 >  (exit $ac_status); }; }; then
8198 >  ac_cv_header_time=yes
8199 > else
8200 >  echo "$as_me: failed program was:" >&5
8201 > sed 's/^/| /' conftest.$ac_ext >&5
8202 >
8203 > ac_cv_header_time=no
8204 > fi
8205 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8206 > fi
8207 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
8208 > echo "${ECHO_T}$ac_cv_header_time" >&6
8209 > if test $ac_cv_header_time = yes; then
8210 >
8211 > cat >>confdefs.h <<\_ACEOF
8212 > #define TIME_WITH_SYS_TIME 1
8213 > _ACEOF
8214 >
8215 > fi
8216 >
8217 > echo "$as_me:$LINENO: checking for clock_t" >&5
8218 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
8219 > if test "${ac_cv_type_clock_t+set}" = set; then
8220 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8221 > else
8222 >  cat >conftest.$ac_ext <<_ACEOF
8223 > /* confdefs.h.  */
8224 > _ACEOF
8225 > cat confdefs.h >>conftest.$ac_ext
8226 > cat >>conftest.$ac_ext <<_ACEOF
8227 > /* end confdefs.h.  */
8228 > $ac_includes_default
8229 > #ifdef FC_DUMMY_MAIN
8230 > #ifndef FC_DUMMY_MAIN_EQ_F77
8231 > #  ifdef __cplusplus
8232 >     extern "C"
8233 > #  endif
8234 >   int FC_DUMMY_MAIN() { return 1; }
8235 > #endif
8236 > #endif
8237 > int
8238 > main ()
8239 > {
8240 > if ((clock_t *) 0)
8241 >  return 0;
8242 > if (sizeof (clock_t))
8243 >  return 0;
8244 >  ;
8245 >  return 0;
8246 > }
8247 > _ACEOF
8248 > rm -f conftest.$ac_objext
8249 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8250 >  (eval $ac_compile) 2>conftest.er1
8251 >  ac_status=$?
8252 >  grep -v '^ *+' conftest.er1 >conftest.err
8253 >  rm -f conftest.er1
8254 >  cat conftest.err >&5
8255 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8256 >  (exit $ac_status); } &&
8257 >         { ac_try='test -z "$ac_c_werror_flag"
8258 >                         || test ! -s conftest.err'
8259 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8260 >  (eval $ac_try) 2>&5
8261 >  ac_status=$?
8262 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8263 >  (exit $ac_status); }; } &&
8264 >         { ac_try='test -s conftest.$ac_objext'
8265 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8266 >  (eval $ac_try) 2>&5
8267 >  ac_status=$?
8268 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8269 >  (exit $ac_status); }; }; then
8270 >  ac_cv_type_clock_t=yes
8271 > else
8272 >  echo "$as_me: failed program was:" >&5
8273 > sed 's/^/| /' conftest.$ac_ext >&5
8274 >
8275 > ac_cv_type_clock_t=no
8276 > fi
8277 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8278 > fi
8279 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
8280 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
8281 > if test $ac_cv_type_clock_t = yes; then
8282 >
8283 > cat >>confdefs.h <<_ACEOF
8284 > #define HAVE_CLOCK_T 1
8285 > _ACEOF
8286 >
8287 >
8288 > fi
8289 >
8290 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
8291 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
8292 > if test "${ac_cv_c_const+set}" = set; then
8293 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8294 > else
8295 >  cat >conftest.$ac_ext <<_ACEOF
8296 > /* confdefs.h.  */
8297 > _ACEOF
8298 > cat confdefs.h >>conftest.$ac_ext
8299 > cat >>conftest.$ac_ext <<_ACEOF
8300 > /* end confdefs.h.  */
8301 >
8302 > #ifdef FC_DUMMY_MAIN
8303 > #ifndef FC_DUMMY_MAIN_EQ_F77
8304 > #  ifdef __cplusplus
8305 >     extern "C"
8306 > #  endif
8307 >   int FC_DUMMY_MAIN() { return 1; }
8308 > #endif
8309 > #endif
8310 > int
8311 > main ()
8312 > {
8313 > /* FIXME: Include the comments suggested by Paul. */
8314 > #ifndef __cplusplus
8315 >  /* Ultrix mips cc rejects this.  */
8316 >  typedef int charset[2];
8317 >  const charset x;
8318 >  /* SunOS 4.1.1 cc rejects this.  */
8319 >  char const *const *ccp;
8320 >  char **p;
8321 >  /* NEC SVR4.0.2 mips cc rejects this.  */
8322 >  struct point {int x, y;};
8323 >  static struct point const zero = {0,0};
8324 >  /* AIX XL C 1.02.0.0 rejects this.
8325 >     It does not let you subtract one const X* pointer from another in
8326 >     an arm of an if-expression whose if-part is not a constant
8327 >     expression */
8328 >  const char *g = "string";
8329 >  ccp = &g + (g ? g-g : 0);
8330 >  /* HPUX 7.0 cc rejects these. */
8331 >  ++ccp;
8332 >  p = (char**) ccp;
8333 >  ccp = (char const *const *) p;
8334 >  { /* SCO 3.2v4 cc rejects this.  */
8335 >    char *t;
8336 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
8337 >
8338 >    *t++ = 0;
8339 >  }
8340 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
8341 >    int x[] = {25, 17};
8342 >    const int *foo = &x[0];
8343 >    ++foo;
8344 >  }
8345 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
8346 >    typedef const int *iptr;
8347 >    iptr p = 0;
8348 >    ++p;
8349 >  }
8350 >  { /* AIX XL C 1.02.0.0 rejects this saying
8351 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
8352 >    struct s { int j; const int *ap[3]; };
8353 >    struct s *b; b->j = 5;
8354 >  }
8355 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
8356 >    const int foo = 10;
8357 >  }
8358 > #endif
8359 >
8360 >  ;
8361 >  return 0;
8362 > }
8363 > _ACEOF
8364 > rm -f conftest.$ac_objext
8365 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8366 >  (eval $ac_compile) 2>conftest.er1
8367 >  ac_status=$?
8368 >  grep -v '^ *+' conftest.er1 >conftest.err
8369 >  rm -f conftest.er1
8370 >  cat conftest.err >&5
8371 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8372 >  (exit $ac_status); } &&
8373 >         { ac_try='test -z "$ac_c_werror_flag"
8374 >                         || test ! -s conftest.err'
8375 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8376 >  (eval $ac_try) 2>&5
8377 >  ac_status=$?
8378 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8379 >  (exit $ac_status); }; } &&
8380 >         { ac_try='test -s conftest.$ac_objext'
8381 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8382 >  (eval $ac_try) 2>&5
8383 >  ac_status=$?
8384 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8385 >  (exit $ac_status); }; }; then
8386 >  ac_cv_c_const=yes
8387 > else
8388 >  echo "$as_me: failed program was:" >&5
8389 > sed 's/^/| /' conftest.$ac_ext >&5
8390 >
8391 > ac_cv_c_const=no
8392 > fi
8393 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8394 > fi
8395 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8396 > echo "${ECHO_T}$ac_cv_c_const" >&6
8397 > if test $ac_cv_c_const = no; then
8398 >
8399 > cat >>confdefs.h <<\_ACEOF
8400 > #define const
8401 > _ACEOF
8402 >
8403 > fi
8404 >
8405 > echo "$as_me:$LINENO: checking for inline" >&5
8406 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8407 > if test "${ac_cv_c_inline+set}" = set; then
8408 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8409 > else
8410 >  ac_cv_c_inline=no
8411 > for ac_kw in inline __inline__ __inline; do
8412 >  cat >conftest.$ac_ext <<_ACEOF
8413 > /* confdefs.h.  */
8414 > _ACEOF
8415 > cat confdefs.h >>conftest.$ac_ext
8416 > cat >>conftest.$ac_ext <<_ACEOF
8417 > /* end confdefs.h.  */
8418 > #ifndef __cplusplus
8419 > typedef int foo_t;
8420 > static $ac_kw foo_t static_foo () {return 0; }
8421 > $ac_kw foo_t foo () {return 0; }
8422 > #endif
8423 >
8424 > _ACEOF
8425 > rm -f conftest.$ac_objext
8426 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8427 >  (eval $ac_compile) 2>conftest.er1
8428 >  ac_status=$?
8429 >  grep -v '^ *+' conftest.er1 >conftest.err
8430 >  rm -f conftest.er1
8431 >  cat conftest.err >&5
8432 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8433 >  (exit $ac_status); } &&
8434 >         { ac_try='test -z "$ac_c_werror_flag"
8435 >                         || test ! -s conftest.err'
8436 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8437 >  (eval $ac_try) 2>&5
8438 >  ac_status=$?
8439 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8440 >  (exit $ac_status); }; } &&
8441 >         { ac_try='test -s conftest.$ac_objext'
8442 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8443 >  (eval $ac_try) 2>&5
8444 >  ac_status=$?
8445 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8446 >  (exit $ac_status); }; }; then
8447 >  ac_cv_c_inline=$ac_kw; break
8448 > else
8449 >  echo "$as_me: failed program was:" >&5
8450 > sed 's/^/| /' conftest.$ac_ext >&5
8451 >
8452 > fi
8453 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8454 > done
8455 >
8456 > fi
8457 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8458 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8459 >
8460 >
8461 > case $ac_cv_c_inline in
8462 >  inline | yes) ;;
8463 >  *)
8464 >    case $ac_cv_c_inline in
8465 >      no) ac_val=;;
8466 >      *) ac_val=$ac_cv_c_inline;;
8467 >    esac
8468 >    cat >>confdefs.h <<_ACEOF
8469 > #ifndef __cplusplus
8470 > #define inline $ac_val
8471 > #endif
8472 > _ACEOF
8473 >    ;;
8474 > esac
8475 >
8476 >
8477 > # Checks for library functions.
8478 >
8479 > for ac_header in stdlib.h
8480 > do
8481 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8482 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8483 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8484 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8485 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8486 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8487 > fi
8488 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8489 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8490 > else
8491 >  # Is the header compilable?
8492 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8493 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8494 > cat >conftest.$ac_ext <<_ACEOF
8495 > /* confdefs.h.  */
8496 > _ACEOF
8497 > cat confdefs.h >>conftest.$ac_ext
8498 > cat >>conftest.$ac_ext <<_ACEOF
8499 > /* end confdefs.h.  */
8500 > $ac_includes_default
8501 > #include <$ac_header>
8502 > _ACEOF
8503 > rm -f conftest.$ac_objext
8504 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8505 >  (eval $ac_compile) 2>conftest.er1
8506 >  ac_status=$?
8507 >  grep -v '^ *+' conftest.er1 >conftest.err
8508 >  rm -f conftest.er1
8509 >  cat conftest.err >&5
8510 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8511 >  (exit $ac_status); } &&
8512 >         { ac_try='test -z "$ac_c_werror_flag"
8513 >                         || test ! -s conftest.err'
8514 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8515 >  (eval $ac_try) 2>&5
8516 >  ac_status=$?
8517 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8518 >  (exit $ac_status); }; } &&
8519 >         { ac_try='test -s conftest.$ac_objext'
8520 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8521 >  (eval $ac_try) 2>&5
8522 >  ac_status=$?
8523 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8524 >  (exit $ac_status); }; }; then
8525 >  ac_header_compiler=yes
8526 > else
8527 >  echo "$as_me: failed program was:" >&5
8528 > sed 's/^/| /' conftest.$ac_ext >&5
8529 >
8530 > ac_header_compiler=no
8531 > fi
8532 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8533 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8534 > echo "${ECHO_T}$ac_header_compiler" >&6
8535 >
8536 > # Is the header present?
8537 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8538 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8539 > cat >conftest.$ac_ext <<_ACEOF
8540 > /* confdefs.h.  */
8541 > _ACEOF
8542 > cat confdefs.h >>conftest.$ac_ext
8543 > cat >>conftest.$ac_ext <<_ACEOF
8544 > /* end confdefs.h.  */
8545 > #include <$ac_header>
8546 > _ACEOF
8547 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8548 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8549 >  ac_status=$?
8550 >  grep -v '^ *+' conftest.er1 >conftest.err
8551 >  rm -f conftest.er1
8552 >  cat conftest.err >&5
8553 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8554 >  (exit $ac_status); } >/dev/null; then
8555 >  if test -s conftest.err; then
8556 >    ac_cpp_err=$ac_c_preproc_warn_flag
8557 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8558 >  else
8559 >    ac_cpp_err=
8560 >  fi
8561 > else
8562 >  ac_cpp_err=yes
8563 > fi
8564 > if test -z "$ac_cpp_err"; then
8565 >  ac_header_preproc=yes
8566 > else
8567 >  echo "$as_me: failed program was:" >&5
8568 > sed 's/^/| /' conftest.$ac_ext >&5
8569 >
8570 >  ac_header_preproc=no
8571 > fi
8572 > rm -f conftest.err conftest.$ac_ext
8573 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8574 > echo "${ECHO_T}$ac_header_preproc" >&6
8575 >
8576 > # So?  What about this header?
8577 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8578 >  yes:no: )
8579 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8580 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8581 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8582 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8583 >    ac_header_preproc=yes
8584 >    ;;
8585 >  no:yes:* )
8586 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8587 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8588 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8589 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8590 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8591 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8592 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8593 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8594 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8595 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8596 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8597 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8598 >    (
8599 >      cat <<\_ASBOX
8600 > ## ------------------------------ ##
8601 > ## Report this to gezelter@nd.edu ##
8602 > ## ------------------------------ ##
8603 > _ASBOX
8604 >    ) |
8605 >      sed "s/^/$as_me: WARNING:     /" >&2
8606 >    ;;
8607 > esac
8608 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8609 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8610 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8611 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8612 > else
8613 >  eval "$as_ac_Header=\$ac_header_preproc"
8614 > fi
8615 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8616 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8617 >
8618 > fi
8619 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8620 >  cat >>confdefs.h <<_ACEOF
8621 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8622 > _ACEOF
8623 >
8624 > fi
8625 >
8626 > done
8627 >
8628 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8629 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8630 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8631 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8632 > else
8633 >  if test "$cross_compiling" = yes; then
8634 >  ac_cv_func_malloc_0_nonnull=no
8635 > else
8636 >  cat >conftest.$ac_ext <<_ACEOF
8637 > /* confdefs.h.  */
8638 > _ACEOF
8639 > cat confdefs.h >>conftest.$ac_ext
8640 > cat >>conftest.$ac_ext <<_ACEOF
8641 > /* end confdefs.h.  */
8642 > #if STDC_HEADERS || HAVE_STDLIB_H
8643 > # include <stdlib.h>
8644 > #else
8645 > char *malloc ();
8646 > #endif
8647 >
8648 > #ifdef FC_DUMMY_MAIN
8649 > #ifndef FC_DUMMY_MAIN_EQ_F77
8650 > #  ifdef __cplusplus
8651 >     extern "C"
8652 > #  endif
8653 >   int FC_DUMMY_MAIN() { return 1; }
8654 > #endif
8655 > #endif
8656 > int
8657 > main ()
8658 > {
8659 > exit (malloc (0) ? 0 : 1);
8660 >  ;
8661 >  return 0;
8662 > }
8663 > _ACEOF
8664 > rm -f conftest$ac_exeext
8665 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8666 >  (eval $ac_link) 2>&5
8667 >  ac_status=$?
8668 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8669 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8670 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8671 >  (eval $ac_try) 2>&5
8672 >  ac_status=$?
8673 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8674 >  (exit $ac_status); }; }; then
8675 >  ac_cv_func_malloc_0_nonnull=yes
8676 > else
8677 >  echo "$as_me: program exited with status $ac_status" >&5
8678 > echo "$as_me: failed program was:" >&5
8679 > sed 's/^/| /' conftest.$ac_ext >&5
8680 >
8681 > ( exit $ac_status )
8682 > ac_cv_func_malloc_0_nonnull=no
8683 > fi
8684 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8685 > fi
8686 > fi
8687 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8688 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8689 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8690 >
8691 > cat >>confdefs.h <<\_ACEOF
8692 > #define HAVE_MALLOC 1
8693 > _ACEOF
8694 >
8695 > else
8696 >  cat >>confdefs.h <<\_ACEOF
8697 > #define HAVE_MALLOC 0
8698 > _ACEOF
8699 >
8700 >   case $LIBOBJS in
8701 >    "malloc.$ac_objext"   | \
8702 >  *" malloc.$ac_objext"   | \
8703 >    "malloc.$ac_objext "* | \
8704 >  *" malloc.$ac_objext "* ) ;;
8705 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8706 > esac
8707 >
8708 >
8709 > cat >>confdefs.h <<\_ACEOF
8710 > #define malloc rpl_malloc
8711 > _ACEOF
8712 >
8713 > fi
8714 >
8715 >
8716 >
8717 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8718 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8719 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8720 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8721 > else
8722 >  if test "$cross_compiling" = yes; then
8723 >  ac_cv_func_memcmp_working=no
8724 > else
8725 >  cat >conftest.$ac_ext <<_ACEOF
8726 > /* confdefs.h.  */
8727 > _ACEOF
8728 > cat confdefs.h >>conftest.$ac_ext
8729 > cat >>conftest.$ac_ext <<_ACEOF
8730 > /* end confdefs.h.  */
8731 > $ac_includes_default
8732 > #ifdef FC_DUMMY_MAIN
8733 > #ifndef FC_DUMMY_MAIN_EQ_F77
8734 > #  ifdef __cplusplus
8735 >     extern "C"
8736 > #  endif
8737 >   int FC_DUMMY_MAIN() { return 1; }
8738 > #endif
8739 > #endif
8740 > int
8741 > main ()
8742 > {
8743 >
8744 >  /* Some versions of memcmp are not 8-bit clean.  */
8745 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8746 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8747 >    exit (1);
8748 >
8749 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8750 >     or more and with at least one buffer not starting on a 4-byte boundary.
8751 >     William Lewis provided this test program.   */
8752 >  {
8753 >    char foo[21];
8754 >    char bar[21];
8755 >    int i;
8756 >    for (i = 0; i < 4; i++)
8757 >      {
8758 >        char *a = foo + i;
8759 >        char *b = bar + i;
8760 >        strcpy (a, "--------01111111");
8761 >        strcpy (b, "--------10000000");
8762 >        if (memcmp (a, b, 16) >= 0)
8763 >          exit (1);
8764 >      }
8765 >    exit (0);
8766 >  }
8767 >
8768 >  ;
8769 >  return 0;
8770 > }
8771 > _ACEOF
8772 > rm -f conftest$ac_exeext
8773 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8774 >  (eval $ac_link) 2>&5
8775 >  ac_status=$?
8776 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8777 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8778 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8779 >  (eval $ac_try) 2>&5
8780 >  ac_status=$?
8781 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8782 >  (exit $ac_status); }; }; then
8783 >  ac_cv_func_memcmp_working=yes
8784 > else
8785 >  echo "$as_me: program exited with status $ac_status" >&5
8786 > echo "$as_me: failed program was:" >&5
8787 > sed 's/^/| /' conftest.$ac_ext >&5
8788 >
8789 > ( exit $ac_status )
8790 > ac_cv_func_memcmp_working=no
8791 > fi
8792 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8793 > fi
8794 > fi
8795 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8796 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8797 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8798 >    "memcmp.$ac_objext"   | \
8799 >  *" memcmp.$ac_objext"   | \
8800 >    "memcmp.$ac_objext "* | \
8801 >  *" memcmp.$ac_objext "* ) ;;
8802 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8803 > esac
8804 >
8805 >
8806 >
8807 > for ac_header in stdlib.h
8808 > do
8809 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8810 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8811 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8812 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8813 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8814 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8815 > fi
8816 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8817 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8818 > else
8819 >  # Is the header compilable?
8820 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8821 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8822 > cat >conftest.$ac_ext <<_ACEOF
8823 > /* confdefs.h.  */
8824 > _ACEOF
8825 > cat confdefs.h >>conftest.$ac_ext
8826 > cat >>conftest.$ac_ext <<_ACEOF
8827 > /* end confdefs.h.  */
8828 > $ac_includes_default
8829 > #include <$ac_header>
8830 > _ACEOF
8831 > rm -f conftest.$ac_objext
8832 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8833 >  (eval $ac_compile) 2>conftest.er1
8834 >  ac_status=$?
8835 >  grep -v '^ *+' conftest.er1 >conftest.err
8836 >  rm -f conftest.er1
8837 >  cat conftest.err >&5
8838 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8839 >  (exit $ac_status); } &&
8840 >         { ac_try='test -z "$ac_c_werror_flag"
8841 >                         || test ! -s conftest.err'
8842 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8843 >  (eval $ac_try) 2>&5
8844 >  ac_status=$?
8845 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8846 >  (exit $ac_status); }; } &&
8847 >         { ac_try='test -s conftest.$ac_objext'
8848 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8849 >  (eval $ac_try) 2>&5
8850 >  ac_status=$?
8851 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8852 >  (exit $ac_status); }; }; then
8853 >  ac_header_compiler=yes
8854 > else
8855 >  echo "$as_me: failed program was:" >&5
8856 > sed 's/^/| /' conftest.$ac_ext >&5
8857 >
8858 > ac_header_compiler=no
8859 > fi
8860 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8861 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8862 > echo "${ECHO_T}$ac_header_compiler" >&6
8863 >
8864 > # Is the header present?
8865 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8866 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8867 > cat >conftest.$ac_ext <<_ACEOF
8868 > /* confdefs.h.  */
8869 > _ACEOF
8870 > cat confdefs.h >>conftest.$ac_ext
8871 > cat >>conftest.$ac_ext <<_ACEOF
8872 > /* end confdefs.h.  */
8873 > #include <$ac_header>
8874 > _ACEOF
8875 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8876 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8877 >  ac_status=$?
8878 >  grep -v '^ *+' conftest.er1 >conftest.err
8879 >  rm -f conftest.er1
8880 >  cat conftest.err >&5
8881 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8882 >  (exit $ac_status); } >/dev/null; then
8883 >  if test -s conftest.err; then
8884 >    ac_cpp_err=$ac_c_preproc_warn_flag
8885 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8886 >  else
8887 >    ac_cpp_err=
8888 >  fi
8889 > else
8890 >  ac_cpp_err=yes
8891 > fi
8892 > if test -z "$ac_cpp_err"; then
8893 >  ac_header_preproc=yes
8894 > else
8895 >  echo "$as_me: failed program was:" >&5
8896 > sed 's/^/| /' conftest.$ac_ext >&5
8897 >
8898 >  ac_header_preproc=no
8899 > fi
8900 > rm -f conftest.err conftest.$ac_ext
8901 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8902 > echo "${ECHO_T}$ac_header_preproc" >&6
8903 >
8904 > # So?  What about this header?
8905 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8906 >  yes:no: )
8907 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8908 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8909 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8910 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8911 >    ac_header_preproc=yes
8912 >    ;;
8913 >  no:yes:* )
8914 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8915 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8916 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8917 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8918 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8919 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8920 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8921 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8922 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8923 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8924 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8925 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8926 >    (
8927 >      cat <<\_ASBOX
8928 > ## ------------------------------ ##
8929 > ## Report this to gezelter@nd.edu ##
8930 > ## ------------------------------ ##
8931 > _ASBOX
8932 >    ) |
8933 >      sed "s/^/$as_me: WARNING:     /" >&2
8934 >    ;;
8935 > esac
8936 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8937 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8938 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8939 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8940 > else
8941 >  eval "$as_ac_Header=\$ac_header_preproc"
8942 > fi
8943 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8944 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8945 >
8946 > fi
8947 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8948 >  cat >>confdefs.h <<_ACEOF
8949 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8950 > _ACEOF
8951 >
8952 > fi
8953 >
8954 > done
8955 >
8956 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8957 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8958 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8959 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8960 > else
8961 >  if test "$cross_compiling" = yes; then
8962 >  ac_cv_func_realloc_0_nonnull=no
8963 > else
8964 >  cat >conftest.$ac_ext <<_ACEOF
8965 > /* confdefs.h.  */
8966 > _ACEOF
8967 > cat confdefs.h >>conftest.$ac_ext
8968 > cat >>conftest.$ac_ext <<_ACEOF
8969 > /* end confdefs.h.  */
8970 > #if STDC_HEADERS || HAVE_STDLIB_H
8971 > # include <stdlib.h>
8972 > #else
8973 > char *realloc ();
8974 > #endif
8975 >
8976 > #ifdef FC_DUMMY_MAIN
8977 > #ifndef FC_DUMMY_MAIN_EQ_F77
8978 > #  ifdef __cplusplus
8979 >     extern "C"
8980 > #  endif
8981 >   int FC_DUMMY_MAIN() { return 1; }
8982 > #endif
8983 > #endif
8984 > int
8985 > main ()
8986 > {
8987 > exit (realloc (0, 0) ? 0 : 1);
8988 >  ;
8989 >  return 0;
8990 > }
8991 > _ACEOF
8992 > rm -f conftest$ac_exeext
8993 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8994 >  (eval $ac_link) 2>&5
8995 >  ac_status=$?
8996 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8997 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8998 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8999 >  (eval $ac_try) 2>&5
9000 >  ac_status=$?
9001 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9002 >  (exit $ac_status); }; }; then
9003 >  ac_cv_func_realloc_0_nonnull=yes
9004 > else
9005 >  echo "$as_me: program exited with status $ac_status" >&5
9006 > echo "$as_me: failed program was:" >&5
9007 > sed 's/^/| /' conftest.$ac_ext >&5
9008 >
9009 > ( exit $ac_status )
9010 > ac_cv_func_realloc_0_nonnull=no
9011 > fi
9012 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9013 > fi
9014 > fi
9015 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
9016 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
9017 > if test $ac_cv_func_realloc_0_nonnull = yes; then
9018 >
9019 > cat >>confdefs.h <<\_ACEOF
9020 > #define HAVE_REALLOC 1
9021 > _ACEOF
9022 >
9023 > else
9024 >  cat >>confdefs.h <<\_ACEOF
9025 > #define HAVE_REALLOC 0
9026 > _ACEOF
9027 >
9028 >   case $LIBOBJS in
9029 >    "realloc.$ac_objext"   | \
9030 >  *" realloc.$ac_objext"   | \
9031 >    "realloc.$ac_objext "* | \
9032 >  *" realloc.$ac_objext "* ) ;;
9033 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
9034 > esac
9035 >
9036 >
9037 > cat >>confdefs.h <<\_ACEOF
9038 > #define realloc rpl_realloc
9039 > _ACEOF
9040 >
9041 > fi
9042 >
9043 >
9044 >
9045 >
9046 >
9047 > for ac_header in sys/select.h sys/socket.h
9048 > do
9049 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9050 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9051 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9052 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9053 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9054 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9055 > fi
9056 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9057 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9058 > else
9059 >  # Is the header compilable?
9060 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9061 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9062 > cat >conftest.$ac_ext <<_ACEOF
9063 > /* confdefs.h.  */
9064 > _ACEOF
9065 > cat confdefs.h >>conftest.$ac_ext
9066 > cat >>conftest.$ac_ext <<_ACEOF
9067 > /* end confdefs.h.  */
9068 > $ac_includes_default
9069 > #include <$ac_header>
9070 > _ACEOF
9071 > rm -f conftest.$ac_objext
9072 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9073 >  (eval $ac_compile) 2>conftest.er1
9074 >  ac_status=$?
9075 >  grep -v '^ *+' conftest.er1 >conftest.err
9076 >  rm -f conftest.er1
9077 >  cat conftest.err >&5
9078 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9079 >  (exit $ac_status); } &&
9080 >         { ac_try='test -z "$ac_c_werror_flag"
9081 >                         || test ! -s conftest.err'
9082 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9083 >  (eval $ac_try) 2>&5
9084 >  ac_status=$?
9085 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9086 >  (exit $ac_status); }; } &&
9087 >         { ac_try='test -s conftest.$ac_objext'
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); }; }; then
9093 >  ac_header_compiler=yes
9094 > else
9095 >  echo "$as_me: failed program was:" >&5
9096 > sed 's/^/| /' conftest.$ac_ext >&5
9097 >
9098 > ac_header_compiler=no
9099 > fi
9100 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9101 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9102 > echo "${ECHO_T}$ac_header_compiler" >&6
9103 >
9104 > # Is the header present?
9105 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9106 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9107 > cat >conftest.$ac_ext <<_ACEOF
9108 > /* confdefs.h.  */
9109 > _ACEOF
9110 > cat confdefs.h >>conftest.$ac_ext
9111 > cat >>conftest.$ac_ext <<_ACEOF
9112 > /* end confdefs.h.  */
9113 > #include <$ac_header>
9114 > _ACEOF
9115 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9116 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9117 >  ac_status=$?
9118 >  grep -v '^ *+' conftest.er1 >conftest.err
9119 >  rm -f conftest.er1
9120 >  cat conftest.err >&5
9121 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9122 >  (exit $ac_status); } >/dev/null; then
9123 >  if test -s conftest.err; then
9124 >    ac_cpp_err=$ac_c_preproc_warn_flag
9125 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9126 >  else
9127 >    ac_cpp_err=
9128 >  fi
9129 > else
9130 >  ac_cpp_err=yes
9131 > fi
9132 > if test -z "$ac_cpp_err"; then
9133 >  ac_header_preproc=yes
9134 > else
9135 >  echo "$as_me: failed program was:" >&5
9136 > sed 's/^/| /' conftest.$ac_ext >&5
9137 >
9138 >  ac_header_preproc=no
9139 > fi
9140 > rm -f conftest.err conftest.$ac_ext
9141 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9142 > echo "${ECHO_T}$ac_header_preproc" >&6
9143 >
9144 > # So?  What about this header?
9145 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9146 >  yes:no: )
9147 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9148 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9149 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9150 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9151 >    ac_header_preproc=yes
9152 >    ;;
9153 >  no:yes:* )
9154 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9155 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9156 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9157 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9158 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9159 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9160 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9161 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9162 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9163 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9164 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9165 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9166 >    (
9167 >      cat <<\_ASBOX
9168 > ## ------------------------------ ##
9169 > ## Report this to gezelter@nd.edu ##
9170 > ## ------------------------------ ##
9171 > _ASBOX
9172 >    ) |
9173 >      sed "s/^/$as_me: WARNING:     /" >&2
9174 >    ;;
9175 > esac
9176 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9177 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9178 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9179 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9180 > else
9181 >  eval "$as_ac_Header=\$ac_header_preproc"
9182 > fi
9183 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9184 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9185 >
9186 > fi
9187 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9188 >  cat >>confdefs.h <<_ACEOF
9189 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9190 > _ACEOF
9191 >
9192 > fi
9193 >
9194 > done
9195 >
9196 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
9197 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
9198 > if test "${ac_cv_func_select_args+set}" = set; then
9199 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9200 > else
9201 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
9202 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
9203 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
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 > $ac_includes_default
9211 > #if HAVE_SYS_SELECT_H
9212 > # include <sys/select.h>
9213 > #endif
9214 > #if HAVE_SYS_SOCKET_H
9215 > # include <sys/socket.h>
9216 > #endif
9217 >
9218 > #ifdef FC_DUMMY_MAIN
9219 > #ifndef FC_DUMMY_MAIN_EQ_F77
9220 > #  ifdef __cplusplus
9221 >     extern "C"
9222 > #  endif
9223 >   int FC_DUMMY_MAIN() { return 1; }
9224 > #endif
9225 > #endif
9226 > int
9227 > main ()
9228 > {
9229 > extern int select ($ac_arg1,
9230 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
9231 >                                            $ac_arg5);
9232 >  ;
9233 >  return 0;
9234 > }
9235 > _ACEOF
9236 > rm -f conftest.$ac_objext
9237 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9238 >  (eval $ac_compile) 2>conftest.er1
9239 >  ac_status=$?
9240 >  grep -v '^ *+' conftest.er1 >conftest.err
9241 >  rm -f conftest.er1
9242 >  cat conftest.err >&5
9243 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9244 >  (exit $ac_status); } &&
9245 >         { ac_try='test -z "$ac_c_werror_flag"
9246 >                         || test ! -s conftest.err'
9247 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9248 >  (eval $ac_try) 2>&5
9249 >  ac_status=$?
9250 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9251 >  (exit $ac_status); }; } &&
9252 >         { ac_try='test -s conftest.$ac_objext'
9253 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9254 >  (eval $ac_try) 2>&5
9255 >  ac_status=$?
9256 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9257 >  (exit $ac_status); }; }; then
9258 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
9259 > else
9260 >  echo "$as_me: failed program was:" >&5
9261 > sed 's/^/| /' conftest.$ac_ext >&5
9262 >
9263 > fi
9264 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9265 >  done
9266 > done
9267 > done
9268 > # Provide a safe default value.
9269 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
9270 >
9271 > fi
9272 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
9273 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
9274 > ac_save_IFS=$IFS; IFS=','
9275 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
9276 > IFS=$ac_save_IFS
9277 > shift
9278 >
9279 > cat >>confdefs.h <<_ACEOF
9280 > #define SELECT_TYPE_ARG1 $1
9281 > _ACEOF
9282 >
9283 >
9284 > cat >>confdefs.h <<_ACEOF
9285 > #define SELECT_TYPE_ARG234 ($2)
9286 > _ACEOF
9287 >
9288 >
9289 > cat >>confdefs.h <<_ACEOF
9290 > #define SELECT_TYPE_ARG5 ($3)
9291 > _ACEOF
9292 >
9293 > rm -f conftest*
9294 >
9295 >
9296 > for ac_func in strftime
9297 > do
9298 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9299 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9300 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9301 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9302 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9303 > else
9304 >  cat >conftest.$ac_ext <<_ACEOF
9305 > /* confdefs.h.  */
9306 > _ACEOF
9307 > cat confdefs.h >>conftest.$ac_ext
9308 > cat >>conftest.$ac_ext <<_ACEOF
9309 > /* end confdefs.h.  */
9310 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9311 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9312 > #define $ac_func innocuous_$ac_func
9313 >
9314 > /* System header to define __stub macros and hopefully few prototypes,
9315 >    which can conflict with char $ac_func (); below.
9316 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9317 >    <limits.h> exists even on freestanding compilers.  */
9318 >
9319 > #ifdef __STDC__
9320 > # include <limits.h>
9321 > #else
9322 > # include <assert.h>
9323 > #endif
9324 >
9325 > #undef $ac_func
9326 >
9327 > /* Override any gcc2 internal prototype to avoid an error.  */
9328 > #ifdef __cplusplus
9329 > extern "C"
9330 > {
9331 > #endif
9332 > /* We use char because int might match the return type of a gcc2
9333 >   builtin and then its argument prototype would still apply.  */
9334 > char $ac_func ();
9335 > /* The GNU C library defines this for functions which it implements
9336 >    to always fail with ENOSYS.  Some functions are actually named
9337 >    something starting with __ and the normal name is an alias.  */
9338 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9339 > choke me
9340 > #else
9341 > char (*f) () = $ac_func;
9342 > #endif
9343 > #ifdef __cplusplus
9344 > }
9345 > #endif
9346 >
9347 > #ifdef FC_DUMMY_MAIN
9348 > #ifndef FC_DUMMY_MAIN_EQ_F77
9349 > #  ifdef __cplusplus
9350 >     extern "C"
9351 > #  endif
9352 >   int FC_DUMMY_MAIN() { return 1; }
9353 > #endif
9354 > #endif
9355 > int
9356 > main ()
9357 > {
9358 > return f != $ac_func;
9359 >  ;
9360 >  return 0;
9361 > }
9362 > _ACEOF
9363 > rm -f conftest.$ac_objext conftest$ac_exeext
9364 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9365 >  (eval $ac_link) 2>conftest.er1
9366 >  ac_status=$?
9367 >  grep -v '^ *+' conftest.er1 >conftest.err
9368 >  rm -f conftest.er1
9369 >  cat conftest.err >&5
9370 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9371 >  (exit $ac_status); } &&
9372 >         { ac_try='test -z "$ac_c_werror_flag"
9373 >                         || test ! -s conftest.err'
9374 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9375 >  (eval $ac_try) 2>&5
9376 >  ac_status=$?
9377 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9378 >  (exit $ac_status); }; } &&
9379 >         { ac_try='test -s conftest$ac_exeext'
9380 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9381 >  (eval $ac_try) 2>&5
9382 >  ac_status=$?
9383 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9384 >  (exit $ac_status); }; }; then
9385 >  eval "$as_ac_var=yes"
9386 > else
9387 >  echo "$as_me: failed program was:" >&5
9388 > sed 's/^/| /' conftest.$ac_ext >&5
9389 >
9390 > eval "$as_ac_var=no"
9391 > fi
9392 > rm -f conftest.err conftest.$ac_objext \
9393 >      conftest$ac_exeext conftest.$ac_ext
9394 > fi
9395 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9396 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9397 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9398 >  cat >>confdefs.h <<_ACEOF
9399 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9400 > _ACEOF
9401 >
9402 > else
9403 >  # strftime is in -lintl on SCO UNIX.
9404 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9405 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9406 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9407 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9408 > else
9409 >  ac_check_lib_save_LIBS=$LIBS
9410 > LIBS="-lintl  $LIBS"
9411 > cat >conftest.$ac_ext <<_ACEOF
9412 > /* confdefs.h.  */
9413 > _ACEOF
9414 > cat confdefs.h >>conftest.$ac_ext
9415 > cat >>conftest.$ac_ext <<_ACEOF
9416 > /* end confdefs.h.  */
9417 >
9418 > /* Override any gcc2 internal prototype to avoid an error.  */
9419 > #ifdef __cplusplus
9420 > extern "C"
9421 > #endif
9422 > /* We use char because int might match the return type of a gcc2
9423 >   builtin and then its argument prototype would still apply.  */
9424 > char strftime ();
9425 > #ifdef FC_DUMMY_MAIN
9426 > #ifndef FC_DUMMY_MAIN_EQ_F77
9427 > #  ifdef __cplusplus
9428 >     extern "C"
9429 > #  endif
9430 >   int FC_DUMMY_MAIN() { return 1; }
9431 > #endif
9432 > #endif
9433 > int
9434 > main ()
9435 > {
9436 > strftime ();
9437 >  ;
9438 >  return 0;
9439 > }
9440 > _ACEOF
9441 > rm -f conftest.$ac_objext conftest$ac_exeext
9442 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9443 >  (eval $ac_link) 2>conftest.er1
9444 >  ac_status=$?
9445 >  grep -v '^ *+' conftest.er1 >conftest.err
9446 >  rm -f conftest.er1
9447 >  cat conftest.err >&5
9448 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9449 >  (exit $ac_status); } &&
9450 >         { ac_try='test -z "$ac_c_werror_flag"
9451 >                         || test ! -s conftest.err'
9452 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9453 >  (eval $ac_try) 2>&5
9454 >  ac_status=$?
9455 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9456 >  (exit $ac_status); }; } &&
9457 >         { ac_try='test -s conftest$ac_exeext'
9458 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9459 >  (eval $ac_try) 2>&5
9460 >  ac_status=$?
9461 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9462 >  (exit $ac_status); }; }; then
9463 >  ac_cv_lib_intl_strftime=yes
9464 > else
9465 >  echo "$as_me: failed program was:" >&5
9466 > sed 's/^/| /' conftest.$ac_ext >&5
9467 >
9468 > ac_cv_lib_intl_strftime=no
9469 > fi
9470 > rm -f conftest.err conftest.$ac_objext \
9471 >      conftest$ac_exeext conftest.$ac_ext
9472 > LIBS=$ac_check_lib_save_LIBS
9473 > fi
9474 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9475 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9476 > if test $ac_cv_lib_intl_strftime = yes; then
9477 >  cat >>confdefs.h <<\_ACEOF
9478 > #define HAVE_STRFTIME 1
9479 > _ACEOF
9480 >
9481 > LIBS="-lintl $LIBS"
9482 > fi
9483 >
9484 > fi
9485 > done
9486 >
9487 > echo "$as_me:$LINENO: checking for working strtod" >&5
9488 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9489 > if test "${ac_cv_func_strtod+set}" = set; then
9490 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9491 > else
9492 >  if test "$cross_compiling" = yes; then
9493 >  ac_cv_func_strtod=no
9494 > else
9495 >  cat >conftest.$ac_ext <<_ACEOF
9496 > /* confdefs.h.  */
9497 > _ACEOF
9498 > cat confdefs.h >>conftest.$ac_ext
9499 > cat >>conftest.$ac_ext <<_ACEOF
9500 > /* end confdefs.h.  */
9501 >
9502 > double strtod ();
9503 > int
9504 > main()
9505 > {
9506 >  {
9507 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9508 >    char *string = " +69";
9509 >    char *term;
9510 >    double value;
9511 >    value = strtod (string, &term);
9512 >    if (value != 69 || term != (string + 4))
9513 >      exit (1);
9514 >  }
9515 >
9516 >  {
9517 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9518 >       terminating character under some conditions.  */
9519 >    char *string = "NaN";
9520 >    char *term;
9521 >    strtod (string, &term);
9522 >    if (term != string && *(term - 1) == 0)
9523 >      exit (1);
9524 >  }
9525 >  exit (0);
9526 > }
9527 >
9528 > _ACEOF
9529 > rm -f conftest$ac_exeext
9530 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9531 >  (eval $ac_link) 2>&5
9532 >  ac_status=$?
9533 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9534 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9535 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9536 >  (eval $ac_try) 2>&5
9537 >  ac_status=$?
9538 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9539 >  (exit $ac_status); }; }; then
9540 >  ac_cv_func_strtod=yes
9541 > else
9542 >  echo "$as_me: program exited with status $ac_status" >&5
9543 > echo "$as_me: failed program was:" >&5
9544 > sed 's/^/| /' conftest.$ac_ext >&5
9545 >
9546 > ( exit $ac_status )
9547 > ac_cv_func_strtod=no
9548 > fi
9549 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9550 > fi
9551 > fi
9552 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9553 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9554 > if test $ac_cv_func_strtod = no; then
9555 >  case $LIBOBJS in
9556 >    "strtod.$ac_objext"   | \
9557 >  *" strtod.$ac_objext"   | \
9558 >    "strtod.$ac_objext "* | \
9559 >  *" strtod.$ac_objext "* ) ;;
9560 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9561 > esac
9562 >
9563 > echo "$as_me:$LINENO: checking for pow" >&5
9564 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9565 > if test "${ac_cv_func_pow+set}" = set; then
9566 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9567 > else
9568 >  cat >conftest.$ac_ext <<_ACEOF
9569 > /* confdefs.h.  */
9570 > _ACEOF
9571 > cat confdefs.h >>conftest.$ac_ext
9572 > cat >>conftest.$ac_ext <<_ACEOF
9573 > /* end confdefs.h.  */
9574 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9575 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9576 > #define pow innocuous_pow
9577 >
9578 > /* System header to define __stub macros and hopefully few prototypes,
9579 >    which can conflict with char pow (); below.
9580 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9581 >    <limits.h> exists even on freestanding compilers.  */
9582 >
9583 > #ifdef __STDC__
9584 > # include <limits.h>
9585 > #else
9586 > # include <assert.h>
9587 > #endif
9588 >
9589 > #undef pow
9590 >
9591 > /* Override any gcc2 internal prototype to avoid an error.  */
9592 > #ifdef __cplusplus
9593 > extern "C"
9594 > {
9595 > #endif
9596 > /* We use char because int might match the return type of a gcc2
9597 >   builtin and then its argument prototype would still apply.  */
9598 > char pow ();
9599 > /* The GNU C library defines this for functions which it implements
9600 >    to always fail with ENOSYS.  Some functions are actually named
9601 >    something starting with __ and the normal name is an alias.  */
9602 > #if defined (__stub_pow) || defined (__stub___pow)
9603 > choke me
9604 > #else
9605 > char (*f) () = pow;
9606 > #endif
9607 > #ifdef __cplusplus
9608 > }
9609 > #endif
9610 >
9611 > #ifdef FC_DUMMY_MAIN
9612 > #ifndef FC_DUMMY_MAIN_EQ_F77
9613 > #  ifdef __cplusplus
9614 >     extern "C"
9615 > #  endif
9616 >   int FC_DUMMY_MAIN() { return 1; }
9617 > #endif
9618 > #endif
9619 > int
9620 > main ()
9621 > {
9622 > return f != pow;
9623 >  ;
9624 >  return 0;
9625 > }
9626 > _ACEOF
9627 > rm -f conftest.$ac_objext conftest$ac_exeext
9628 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9629 >  (eval $ac_link) 2>conftest.er1
9630 >  ac_status=$?
9631 >  grep -v '^ *+' conftest.er1 >conftest.err
9632 >  rm -f conftest.er1
9633 >  cat conftest.err >&5
9634 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9635 >  (exit $ac_status); } &&
9636 >         { ac_try='test -z "$ac_c_werror_flag"
9637 >                         || test ! -s conftest.err'
9638 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9639 >  (eval $ac_try) 2>&5
9640 >  ac_status=$?
9641 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9642 >  (exit $ac_status); }; } &&
9643 >         { ac_try='test -s conftest$ac_exeext'
9644 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9645 >  (eval $ac_try) 2>&5
9646 >  ac_status=$?
9647 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9648 >  (exit $ac_status); }; }; then
9649 >  ac_cv_func_pow=yes
9650 > else
9651 >  echo "$as_me: failed program was:" >&5
9652 > sed 's/^/| /' conftest.$ac_ext >&5
9653 >
9654 > ac_cv_func_pow=no
9655 > fi
9656 > rm -f conftest.err conftest.$ac_objext \
9657 >      conftest$ac_exeext conftest.$ac_ext
9658 > fi
9659 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9660 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9661 >
9662 > if test $ac_cv_func_pow = no; then
9663 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9664 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9665 > if test "${ac_cv_lib_m_pow+set}" = set; then
9666 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9667 > else
9668 >  ac_check_lib_save_LIBS=$LIBS
9669 > LIBS="-lm  $LIBS"
9670 > cat >conftest.$ac_ext <<_ACEOF
9671 > /* confdefs.h.  */
9672 > _ACEOF
9673 > cat confdefs.h >>conftest.$ac_ext
9674 > cat >>conftest.$ac_ext <<_ACEOF
9675 > /* end confdefs.h.  */
9676 >
9677 > /* Override any gcc2 internal prototype to avoid an error.  */
9678 > #ifdef __cplusplus
9679 > extern "C"
9680 > #endif
9681 > /* We use char because int might match the return type of a gcc2
9682 >   builtin and then its argument prototype would still apply.  */
9683 > char pow ();
9684 > #ifdef FC_DUMMY_MAIN
9685 > #ifndef FC_DUMMY_MAIN_EQ_F77
9686 > #  ifdef __cplusplus
9687 >     extern "C"
9688 > #  endif
9689 >   int FC_DUMMY_MAIN() { return 1; }
9690 > #endif
9691 > #endif
9692 > int
9693 > main ()
9694 > {
9695 > pow ();
9696 >  ;
9697 >  return 0;
9698 > }
9699 > _ACEOF
9700 > rm -f conftest.$ac_objext conftest$ac_exeext
9701 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9702 >  (eval $ac_link) 2>conftest.er1
9703 >  ac_status=$?
9704 >  grep -v '^ *+' conftest.er1 >conftest.err
9705 >  rm -f conftest.er1
9706 >  cat conftest.err >&5
9707 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9708 >  (exit $ac_status); } &&
9709 >         { ac_try='test -z "$ac_c_werror_flag"
9710 >                         || test ! -s conftest.err'
9711 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9712 >  (eval $ac_try) 2>&5
9713 >  ac_status=$?
9714 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9715 >  (exit $ac_status); }; } &&
9716 >         { ac_try='test -s conftest$ac_exeext'
9717 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9718 >  (eval $ac_try) 2>&5
9719 >  ac_status=$?
9720 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9721 >  (exit $ac_status); }; }; then
9722 >  ac_cv_lib_m_pow=yes
9723 > else
9724 >  echo "$as_me: failed program was:" >&5
9725 > sed 's/^/| /' conftest.$ac_ext >&5
9726 >
9727 > ac_cv_lib_m_pow=no
9728 > fi
9729 > rm -f conftest.err conftest.$ac_objext \
9730 >      conftest$ac_exeext conftest.$ac_ext
9731 > LIBS=$ac_check_lib_save_LIBS
9732 > fi
9733 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9734 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9735 > if test $ac_cv_lib_m_pow = yes; then
9736 >  POW_LIB=-lm
9737 > else
9738 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9739 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9740 > fi
9741 >
9742 > fi
9743 >
9744 > fi
9745 >
9746 >
9747 >
9748 >
9749 >
9750 >
9751 >
9752 >
9753 >
9754 >
9755 >
9756 >
9757 >
9758 >
9759 >
9760 >
9761 >
9762 >
9763 >
9764 >
9765 >
9766 >
9767 >
9768 >
9769 >
9770 >
9771 >
9772 >
9773 > 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
9774 > do
9775 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9776 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9777 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9778 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9779 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9780 > else
9781 >  cat >conftest.$ac_ext <<_ACEOF
9782 > /* confdefs.h.  */
9783 > _ACEOF
9784 > cat confdefs.h >>conftest.$ac_ext
9785 > cat >>conftest.$ac_ext <<_ACEOF
9786 > /* end confdefs.h.  */
9787 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9788 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9789 > #define $ac_func innocuous_$ac_func
9790 >
9791 > /* System header to define __stub macros and hopefully few prototypes,
9792 >    which can conflict with char $ac_func (); below.
9793 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9794 >    <limits.h> exists even on freestanding compilers.  */
9795 >
9796 > #ifdef __STDC__
9797 > # include <limits.h>
9798 > #else
9799 > # include <assert.h>
9800 > #endif
9801 >
9802 > #undef $ac_func
9803 >
9804 > /* Override any gcc2 internal prototype to avoid an error.  */
9805 > #ifdef __cplusplus
9806 > extern "C"
9807 > {
9808 > #endif
9809 > /* We use char because int might match the return type of a gcc2
9810 >   builtin and then its argument prototype would still apply.  */
9811 > char $ac_func ();
9812 > /* The GNU C library defines this for functions which it implements
9813 >    to always fail with ENOSYS.  Some functions are actually named
9814 >    something starting with __ and the normal name is an alias.  */
9815 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9816 > choke me
9817 > #else
9818 > char (*f) () = $ac_func;
9819 > #endif
9820 > #ifdef __cplusplus
9821 > }
9822 > #endif
9823 >
9824 > #ifdef FC_DUMMY_MAIN
9825 > #ifndef FC_DUMMY_MAIN_EQ_F77
9826 > #  ifdef __cplusplus
9827 >     extern "C"
9828 > #  endif
9829 >   int FC_DUMMY_MAIN() { return 1; }
9830 > #endif
9831 > #endif
9832 > int
9833 > main ()
9834 > {
9835 > return f != $ac_func;
9836 >  ;
9837 >  return 0;
9838 > }
9839 > _ACEOF
9840 > rm -f conftest.$ac_objext conftest$ac_exeext
9841 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9842 >  (eval $ac_link) 2>conftest.er1
9843 >  ac_status=$?
9844 >  grep -v '^ *+' conftest.er1 >conftest.err
9845 >  rm -f conftest.er1
9846 >  cat conftest.err >&5
9847 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9848 >  (exit $ac_status); } &&
9849 >         { ac_try='test -z "$ac_c_werror_flag"
9850 >                         || test ! -s conftest.err'
9851 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9852 >  (eval $ac_try) 2>&5
9853 >  ac_status=$?
9854 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9855 >  (exit $ac_status); }; } &&
9856 >         { ac_try='test -s conftest$ac_exeext'
9857 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9858 >  (eval $ac_try) 2>&5
9859 >  ac_status=$?
9860 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9861 >  (exit $ac_status); }; }; then
9862 >  eval "$as_ac_var=yes"
9863 > else
9864 >  echo "$as_me: failed program was:" >&5
9865 > sed 's/^/| /' conftest.$ac_ext >&5
9866 >
9867 > eval "$as_ac_var=no"
9868 > fi
9869 > rm -f conftest.err conftest.$ac_objext \
9870 >      conftest$ac_exeext conftest.$ac_ext
9871 > fi
9872 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9873 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9874 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9875 >  cat >>confdefs.h <<_ACEOF
9876 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9877 > _ACEOF
9878 >
9879 > fi
9880 > done
9881 >
9882 >
9883 > # special check for _system_configuration because AIX <4.3.2 do not
9884 > # contain the `physmem' member.
9885 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9886 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9887 > cat >conftest.$ac_ext <<_ACEOF
9888 > /* confdefs.h.  */
9889 > _ACEOF
9890 > cat confdefs.h >>conftest.$ac_ext
9891 > cat >>conftest.$ac_ext <<_ACEOF
9892 > /* end confdefs.h.  */
9893 > #include <sys/systemcfg.h>
9894 > #ifdef FC_DUMMY_MAIN
9895 > #ifndef FC_DUMMY_MAIN_EQ_F77
9896 > #  ifdef __cplusplus
9897 >     extern "C"
9898 > #  endif
9899 >   int FC_DUMMY_MAIN() { return 1; }
9900 > #endif
9901 > #endif
9902 > int
9903 > main ()
9904 > {
9905 > double x = _system_configuration.physmem;
9906 >  ;
9907 >  return 0;
9908 > }
9909 > _ACEOF
9910 > rm -f conftest.$ac_objext
9911 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9912 >  (eval $ac_compile) 2>conftest.er1
9913 >  ac_status=$?
9914 >  grep -v '^ *+' conftest.er1 >conftest.err
9915 >  rm -f conftest.er1
9916 >  cat conftest.err >&5
9917 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9918 >  (exit $ac_status); } &&
9919 >         { ac_try='test -z "$ac_c_werror_flag"
9920 >                         || test ! -s conftest.err'
9921 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9922 >  (eval $ac_try) 2>&5
9923 >  ac_status=$?
9924 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9925 >  (exit $ac_status); }; } &&
9926 >         { ac_try='test -s conftest.$ac_objext'
9927 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9928 >  (eval $ac_try) 2>&5
9929 >  ac_status=$?
9930 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9931 >  (exit $ac_status); }; }; then
9932 >  echo "$as_me:$LINENO: result: yes" >&5
9933 > echo "${ECHO_T}yes" >&6
9934 >
9935 > cat >>confdefs.h <<\_ACEOF
9936 > #define HAVE__SYSTEM_CONFIGURATION 1
9937 > _ACEOF
9938 >
9939 > else
9940 >  echo "$as_me: failed program was:" >&5
9941 > sed 's/^/| /' conftest.$ac_ext >&5
9942 >
9943 > echo "$as_me:$LINENO: result: no" >&5
9944 > echo "${ECHO_T}no" >&6
9945 > fi
9946 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9947 >
9948 >  # clean out junk possibly left behind by a previous configuration
9949 >  rm -f src/getopt.h
9950 >  # Check for getopt_long support
9951 >
9952 > for ac_header in getopt.h
9953 > do
9954 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9955 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9956 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9957 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9958 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9959 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9960 > fi
9961 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9962 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9963 > else
9964 >  # Is the header compilable?
9965 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9966 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9967 > cat >conftest.$ac_ext <<_ACEOF
9968 > /* confdefs.h.  */
9969 > _ACEOF
9970 > cat confdefs.h >>conftest.$ac_ext
9971 > cat >>conftest.$ac_ext <<_ACEOF
9972 > /* end confdefs.h.  */
9973 > $ac_includes_default
9974 > #include <$ac_header>
9975 > _ACEOF
9976 > rm -f conftest.$ac_objext
9977 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9978 >  (eval $ac_compile) 2>conftest.er1
9979 >  ac_status=$?
9980 >  grep -v '^ *+' conftest.er1 >conftest.err
9981 >  rm -f conftest.er1
9982 >  cat conftest.err >&5
9983 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9984 >  (exit $ac_status); } &&
9985 >         { ac_try='test -z "$ac_c_werror_flag"
9986 >                         || test ! -s conftest.err'
9987 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9988 >  (eval $ac_try) 2>&5
9989 >  ac_status=$?
9990 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9991 >  (exit $ac_status); }; } &&
9992 >         { ac_try='test -s conftest.$ac_objext'
9993 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9994 >  (eval $ac_try) 2>&5
9995 >  ac_status=$?
9996 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9997 >  (exit $ac_status); }; }; then
9998 >  ac_header_compiler=yes
9999 > else
10000 >  echo "$as_me: failed program was:" >&5
10001 > sed 's/^/| /' conftest.$ac_ext >&5
10002 >
10003 > ac_header_compiler=no
10004 > fi
10005 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10006 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10007 > echo "${ECHO_T}$ac_header_compiler" >&6
10008 >
10009 > # Is the header present?
10010 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10011 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10012 > cat >conftest.$ac_ext <<_ACEOF
10013 > /* confdefs.h.  */
10014 > _ACEOF
10015 > cat confdefs.h >>conftest.$ac_ext
10016 > cat >>conftest.$ac_ext <<_ACEOF
10017 > /* end confdefs.h.  */
10018 > #include <$ac_header>
10019 > _ACEOF
10020 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10021 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10022 >  ac_status=$?
10023 >  grep -v '^ *+' conftest.er1 >conftest.err
10024 >  rm -f conftest.er1
10025 >  cat conftest.err >&5
10026 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10027 >  (exit $ac_status); } >/dev/null; then
10028 >  if test -s conftest.err; then
10029 >    ac_cpp_err=$ac_c_preproc_warn_flag
10030 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10031 >  else
10032 >    ac_cpp_err=
10033 >  fi
10034 > else
10035 >  ac_cpp_err=yes
10036 > fi
10037 > if test -z "$ac_cpp_err"; then
10038 >  ac_header_preproc=yes
10039 > else
10040 >  echo "$as_me: failed program was:" >&5
10041 > sed 's/^/| /' conftest.$ac_ext >&5
10042 >
10043 >  ac_header_preproc=no
10044 > fi
10045 > rm -f conftest.err conftest.$ac_ext
10046 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10047 > echo "${ECHO_T}$ac_header_preproc" >&6
10048 >
10049 > # So?  What about this header?
10050 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10051 >  yes:no: )
10052 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10053 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10054 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10055 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10056 >    ac_header_preproc=yes
10057 >    ;;
10058 >  no:yes:* )
10059 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10060 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10061 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10062 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10063 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10064 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10065 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10066 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10067 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10068 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10069 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10070 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10071 >    (
10072 >      cat <<\_ASBOX
10073 > ## ------------------------------ ##
10074 > ## Report this to gezelter@nd.edu ##
10075 > ## ------------------------------ ##
10076 > _ASBOX
10077 >    ) |
10078 >      sed "s/^/$as_me: WARNING:     /" >&2
10079 >    ;;
10080 > esac
10081 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10082 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10083 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10084 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10085 > else
10086 >  eval "$as_ac_Header=\$ac_header_preproc"
10087 > fi
10088 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10089 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10090 >
10091 > fi
10092 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10093 >  cat >>confdefs.h <<_ACEOF
10094 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10095 > _ACEOF
10096 >
10097 > fi
10098 >
10099 > done
10100 >
10101 >
10102 > for ac_func in getopt_long
10103 > do
10104 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
10105 > echo "$as_me:$LINENO: checking for $ac_func" >&5
10106 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
10107 > if eval "test \"\${$as_ac_var+set}\" = set"; then
10108 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10109 > else
10110 >  cat >conftest.$ac_ext <<_ACEOF
10111 > /* confdefs.h.  */
10112 > _ACEOF
10113 > cat confdefs.h >>conftest.$ac_ext
10114 > cat >>conftest.$ac_ext <<_ACEOF
10115 > /* end confdefs.h.  */
10116 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
10117 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
10118 > #define $ac_func innocuous_$ac_func
10119 >
10120 > /* System header to define __stub macros and hopefully few prototypes,
10121 >    which can conflict with char $ac_func (); below.
10122 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10123 >    <limits.h> exists even on freestanding compilers.  */
10124 >
10125 > #ifdef __STDC__
10126 > # include <limits.h>
10127 > #else
10128 > # include <assert.h>
10129 > #endif
10130 >
10131 > #undef $ac_func
10132 >
10133 > /* Override any gcc2 internal prototype to avoid an error.  */
10134 > #ifdef __cplusplus
10135 > extern "C"
10136 > {
10137 > #endif
10138 > /* We use char because int might match the return type of a gcc2
10139 >   builtin and then its argument prototype would still apply.  */
10140 > char $ac_func ();
10141 > /* The GNU C library defines this for functions which it implements
10142 >    to always fail with ENOSYS.  Some functions are actually named
10143 >    something starting with __ and the normal name is an alias.  */
10144 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
10145 > choke me
10146 > #else
10147 > char (*f) () = $ac_func;
10148 > #endif
10149 > #ifdef __cplusplus
10150 > }
10151 > #endif
10152 >
10153 > #ifdef FC_DUMMY_MAIN
10154 > #ifndef FC_DUMMY_MAIN_EQ_F77
10155 > #  ifdef __cplusplus
10156 >     extern "C"
10157 > #  endif
10158 >   int FC_DUMMY_MAIN() { return 1; }
10159 > #endif
10160 > #endif
10161 > int
10162 > main ()
10163 > {
10164 > return f != $ac_func;
10165 >  ;
10166 >  return 0;
10167 > }
10168 > _ACEOF
10169 > rm -f conftest.$ac_objext conftest$ac_exeext
10170 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10171 >  (eval $ac_link) 2>conftest.er1
10172 >  ac_status=$?
10173 >  grep -v '^ *+' conftest.er1 >conftest.err
10174 >  rm -f conftest.er1
10175 >  cat conftest.err >&5
10176 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10177 >  (exit $ac_status); } &&
10178 >         { ac_try='test -z "$ac_c_werror_flag"
10179 >                         || test ! -s conftest.err'
10180 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10181 >  (eval $ac_try) 2>&5
10182 >  ac_status=$?
10183 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10184 >  (exit $ac_status); }; } &&
10185 >         { ac_try='test -s conftest$ac_exeext'
10186 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10187 >  (eval $ac_try) 2>&5
10188 >  ac_status=$?
10189 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10190 >  (exit $ac_status); }; }; then
10191 >  eval "$as_ac_var=yes"
10192 > else
10193 >  echo "$as_me: failed program was:" >&5
10194 > sed 's/^/| /' conftest.$ac_ext >&5
10195 >
10196 > eval "$as_ac_var=no"
10197 > fi
10198 > rm -f conftest.err conftest.$ac_objext \
10199 >      conftest$ac_exeext conftest.$ac_ext
10200 > fi
10201 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
10202 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
10203 > if test `eval echo '${'$as_ac_var'}'` = yes; then
10204 >  cat >>confdefs.h <<_ACEOF
10205 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
10206 > _ACEOF
10207 >
10208 > else
10209 >  # FreeBSD has a gnugetopt library for this
10210 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
10211 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
10212 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
10213 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10214 > else
10215 >  ac_check_lib_save_LIBS=$LIBS
10216 > LIBS="-lgnugetopt  $LIBS"
10217 > cat >conftest.$ac_ext <<_ACEOF
10218 > /* confdefs.h.  */
10219 > _ACEOF
10220 > cat confdefs.h >>conftest.$ac_ext
10221 > cat >>conftest.$ac_ext <<_ACEOF
10222 > /* end confdefs.h.  */
10223 >
10224 > /* Override any gcc2 internal prototype to avoid an error.  */
10225 > #ifdef __cplusplus
10226 > extern "C"
10227 > #endif
10228 > /* We use char because int might match the return type of a gcc2
10229 >   builtin and then its argument prototype would still apply.  */
10230 > char getopt_long ();
10231 > #ifdef FC_DUMMY_MAIN
10232 > #ifndef FC_DUMMY_MAIN_EQ_F77
10233 > #  ifdef __cplusplus
10234 >     extern "C"
10235 > #  endif
10236 >   int FC_DUMMY_MAIN() { return 1; }
10237 > #endif
10238 > #endif
10239 > int
10240 > main ()
10241 > {
10242 > getopt_long ();
10243 >  ;
10244 >  return 0;
10245 > }
10246   _ACEOF
10247 < ;;
10248 <  "upper case, no underscore, no extra underscore")
10249 <          cat >>confdefs.h <<\_ACEOF
10250 < #define F90_FUNC(name,NAME) NAME
10251 < _ACEOF
10247 > rm -f conftest.$ac_objext conftest$ac_exeext
10248 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10249 >  (eval $ac_link) 2>conftest.er1
10250 >  ac_status=$?
10251 >  grep -v '^ *+' conftest.er1 >conftest.err
10252 >  rm -f conftest.er1
10253 >  cat conftest.err >&5
10254 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10255 >  (exit $ac_status); } &&
10256 >         { ac_try='test -z "$ac_c_werror_flag"
10257 >                         || test ! -s conftest.err'
10258 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10259 >  (eval $ac_try) 2>&5
10260 >  ac_status=$?
10261 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10262 >  (exit $ac_status); }; } &&
10263 >         { ac_try='test -s conftest$ac_exeext'
10264 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10265 >  (eval $ac_try) 2>&5
10266 >  ac_status=$?
10267 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10268 >  (exit $ac_status); }; }; then
10269 >  ac_cv_lib_gnugetopt_getopt_long=yes
10270 > else
10271 >  echo "$as_me: failed program was:" >&5
10272 > sed 's/^/| /' conftest.$ac_ext >&5
10273  
10274 <          cat >>confdefs.h <<\_ACEOF
10275 < #define F90_FUNC_(name,NAME) NAME
10274 > ac_cv_lib_gnugetopt_getopt_long=no
10275 > fi
10276 > rm -f conftest.err conftest.$ac_objext \
10277 >      conftest$ac_exeext conftest.$ac_ext
10278 > LIBS=$ac_check_lib_save_LIBS
10279 > fi
10280 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
10281 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
10282 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
10283 >  cat >>confdefs.h <<\_ACEOF
10284 > #define HAVE_GETOPT_LONG 1
10285   _ACEOF
3853 ;;
3854  "upper case, no underscore, extra underscore")
3855          cat >>confdefs.h <<\_ACEOF
3856 #define F90_FUNC(name,NAME) NAME
3857 _ACEOF
10286  
10287 <          cat >>confdefs.h <<\_ACEOF
10288 < #define F90_FUNC_(name,NAME) NAME ## _
10289 < _ACEOF
10290 < ;;
10291 <  "upper case, underscore, no extra underscore")
10292 <          cat >>confdefs.h <<\_ACEOF
10293 < #define F90_FUNC(name,NAME) NAME ## _
10294 < _ACEOF
10287 > else
10288 >  # use the GNU replacement
10289 >      case $LIBOBJS in
10290 >    "getopt.$ac_objext"   | \
10291 >  *" getopt.$ac_objext"   | \
10292 >    "getopt.$ac_objext "* | \
10293 >  *" getopt.$ac_objext "* ) ;;
10294 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
10295 > esac
10296  
10297 <          cat >>confdefs.h <<\_ACEOF
10298 < #define F90_FUNC_(name,NAME) NAME ## _
10299 < _ACEOF
10300 < ;;
10301 <  "upper case, underscore, extra underscore")
10302 <          cat >>confdefs.h <<\_ACEOF
3874 < #define F90_FUNC(name,NAME) NAME ## _
3875 < _ACEOF
3876 <
3877 <          cat >>confdefs.h <<\_ACEOF
3878 < #define F90_FUNC_(name,NAME) NAME ## __
3879 < _ACEOF
3880 < ;;
3881 <  *)
3882 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
3883 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
3884 <          ;;
10297 >      case $LIBOBJS in
10298 >    "getopt1.$ac_objext"   | \
10299 >  *" getopt1.$ac_objext"   | \
10300 >    "getopt1.$ac_objext "* | \
10301 >  *" getopt1.$ac_objext "* ) ;;
10302 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
10303   esac
10304  
10305 +                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
10306  
10307 + fi
10308  
3889
3890
3891 echo "$as_me:$LINENO: checking for module suffix" >&5
3892 echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
3893 rm -f conftest*
3894 # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
3895 rm -f work*
3896 cat >conftest.f90 <<EOF
3897        module conftest
3898        integer n
3899        parameter (n=1)
3900        end module conftest
3901 EOF
3902 # SGI and absoft compilers generates module name in upper case!
3903 testname="conftest"
3904 modcase="lower"
3905 if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
3906    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
3907    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
3908    if test -z "$MOD" ; then
3909        MOD=`ls CONFTEST* 2>/dev/null \
3910                | grep -v CONFTEST.f | grep -v CONFTEST.o`
3911        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
3912        if test -n "$MOD" ; then
3913            testname="CONFTEST"
3914            modcase="upper"
3915        fi
3916    fi
3917    if test -z "$MOD" ; then
3918        echo "$as_me:$LINENO: result: unknown" >&5
3919 echo "${ECHO_T}unknown" >&6
3920        # Use mod if we can't figure it out
3921        MOD="mod"
3922    else
3923        echo "$as_me:$LINENO: result: $MOD" >&5
3924 echo "${ECHO_T}$MOD" >&6
3925    fi
3926    if test -s work.pcl ; then
3927        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
3928 echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
3929    fi
3930 else
3931    echo "$as_me:$LINENO: result: unknown" >&5
3932 echo "${ECHO_T}unknown" >&6
10309   fi
10310 + done
10311  
10312  
10313 + ac_ext=cc
10314 + ac_cpp='$CXXCPP $CPPFLAGS'
10315 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10316 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10317 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10318  
10319  
10320 + echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
10321 + echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
10322 + if test "${ac_cv_cxx_namespaces+set}" = set; then
10323 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10324 + else
10325  
3939 # Check for module include path (some use -I, some (Solaris) use -M, some
3940 # (absoft) use -p).
3941 # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
3942 # specified, work.pcl and work.pc are created.  However, if you specify
3943 # a file, it must contain a the name of a file ending in .pc .  Ugh!
3944 # Use the module made above
3945 echo "$as_me:$LINENO: checking for module directory path flag" >&5
3946 echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
3947 rm -f conftest*
3948 # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
3949 rm -f work*
3950 cat >conftest.f90 <<EOF
3951        module conftest
3952        integer n
3953        parameter (n=1)
3954        end module conftest
3955 EOF
3956 # SGI and absoft compilers generates module name in upper case!
3957 testname="conftest"
3958 if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
3959   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
3960   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
3961   if test -n "$mod" ; then
3962      testname="CONFTEST"
3963   fi
3964   madedir=0
3965   if test ! -d conf ; then mkdir conf ; madedir=1; fi
3966   cp $testname.$MOD conf
3967   rm -f conftest* CONFTEST*
3968   cat >conftest1.f90 <<EOF
3969        program main
3970        use conftest
3971        print *, n
3972        end
3973 EOF
3974   F90_WORK_FILES_ARG=""
3975   F90MODINCSPEC=""
3976   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
3977       MODDIRFLAG="-I"
3978       F90MODINCSPEC="-I<dir>"
3979       echo "$as_me:$LINENO: result: -I" >&5
3980 echo "${ECHO_T}-I" >&6
3981   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
3982       MODDIRFLAG="-M"
3983       F90MODINCSPEC="-M<dir>"
3984       echo "$as_me:$LINENO: result: -M" >&5
3985 echo "${ECHO_T}-M" >&6
3986   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
3987       MODDIRFLAG="-p"
3988       F90MODINCSPEC="-p<dir>"
3989       echo "$as_me:$LINENO: result: -p" >&5
3990 echo "${ECHO_T}-p" >&6
3991   elif test -s work.pc ; then
3992        cp work.pc conf/mpimod.pc
3993        echo "mpimod.pc" > conf/mpimod.pcl
3994        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
3995        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
3996            MODDIRFLAG='-cl,mpimod.pcl'
3997            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
3998 echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
3999            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
4000            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
10326  
10327 <        else
10328 <            # The version of the Intel compiler that I have refuses to let
10329 <            # you put the "work catalog" list anywhere but the current
10330 <            # directory. For example, you cannot in
10331 <         :
4007 <        fi
4008 <   fi
4009 <   if test -z "MODDIRFLAG" ; then
4010 <       echo "$as_me:$LINENO: result: unknown" >&5
4011 < echo "${ECHO_T}unknown" >&6
4012 <   fi
10327 > ac_ext=cc
10328 > ac_cpp='$CXXCPP $CPPFLAGS'
10329 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10330 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10331 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10332  
10333 <
10334 <   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
10335 <   if test $madedir = 1 ; then rmdir conf ; fi
10336 < fi
10337 <
10338 <
10339 < echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
10340 < echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
10341 < if test "${ac_cv_f90_module_names+set}" = set; then
10342 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10343 < else
10344 <  ac_ext=f90
10345 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
10346 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10347 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
10348 <
10349 < # carry out the test in a new directory, so that we don't miss anything
10350 < mkdir conftest
10351 < cd conftest
10352 < cat >conftest.$ac_ext <<_ACEOF
10353 < MODULE Bar
10354 < END MODULE Bar
10355 < _ACEOF
10356 < rm -f conftest.$ac_objext
10357 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10358 <  (eval $ac_compile) 2>&5
10333 > cat >conftest.$ac_ext <<_ACEOF
10334 > /* confdefs.h.  */
10335 > _ACEOF
10336 > cat confdefs.h >>conftest.$ac_ext
10337 > cat >>conftest.$ac_ext <<_ACEOF
10338 > /* end confdefs.h.  */
10339 > namespace Outer { namespace Inner { int i = 0; }}
10340 > #ifdef FC_DUMMY_MAIN
10341 > #ifndef FC_DUMMY_MAIN_EQ_F77
10342 > #  ifdef __cplusplus
10343 >     extern "C"
10344 > #  endif
10345 >   int FC_DUMMY_MAIN() { return 1; }
10346 > #endif
10347 > #endif
10348 > int
10349 > main ()
10350 > {
10351 > using namespace Outer::Inner; return i;
10352 >  ;
10353 >  return 0;
10354 > }
10355 > _ACEOF
10356 > rm -f conftest.$ac_objext
10357 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10358 >  (eval $ac_compile) 2>conftest.er1
10359 >  ac_status=$?
10360 >  grep -v '^ *+' conftest.er1 >conftest.err
10361 >  rm -f conftest.er1
10362 >  cat conftest.err >&5
10363 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10364 >  (exit $ac_status); } &&
10365 >         { ac_try='test -z "$ac_cxx_werror_flag"
10366 >                         || test ! -s conftest.err'
10367 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10368 >  (eval $ac_try) 2>&5
10369    ac_status=$?
10370    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10371 <  (exit $ac_status); } &&
10372 <         { ac_try='test -s conftest.$ac_objext'
10371 >  (exit $ac_status); }; } &&
10372 >         { ac_try='test -s conftest.$ac_objext'
10373    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10374    (eval $ac_try) 2>&5
10375    ac_status=$?
10376    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10377    (exit $ac_status); }; }; then
10378 <  ac_cv_f90_module_names=
4050 < ac_file_list=*
4051 < for ac_file in $ac_file_list; do
4052 <   case $ac_file in
4053 <      # don't care for original source and object files
4054 <      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
4055 <          :
4056 <          ;;
4057 <      # look for new files derived from the file name
4058 <      *conftest*)
4059 <          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
4060 <            ac_exists=false
4061 <  for ac_i in $ac_cv_f90_module_names; do
4062 <    if test x"$ac_pat" = x"$ac_i"; then
4063 <      ac_exists=true
4064 <      break
4065 <    fi
4066 <  done
4067 <
4068 <  if test x"$ac_exists" = xtrue; then
4069 <  :
10378 >  ac_cv_cxx_namespaces=yes
10379   else
4071  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4072 fi
4073
4074          ;;
4075      # look for new files derived from the module name,
4076      # with different case translation schemes
4077      *Bar*)
4078          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
4079            ac_exists=false
4080  for ac_i in $ac_cv_f90_module_names; do
4081    if test x"$ac_pat" = x"$ac_i"; then
4082      ac_exists=true
4083      break
4084    fi
4085  done
4086
4087  if test x"$ac_exists" = xtrue; then
4088  :
4089 else
4090  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4091 fi
4092
4093          ;;
4094      *bar*)
4095          ac_pat=`echo $ac_file | sed s/bar/%module%/`
4096            ac_exists=false
4097  for ac_i in $ac_cv_f90_module_names; do
4098    if test x"$ac_pat" = x"$ac_i"; then
4099      ac_exists=true
4100      break
4101    fi
4102  done
4103
4104  if test x"$ac_exists" = xtrue; then
4105  :
4106 else
4107  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4108 fi
4109
4110          ;;
4111      *BAR*)
4112          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
4113            ac_exists=false
4114  for ac_i in $ac_cv_f90_module_names; do
4115    if test x"$ac_pat" = x"$ac_i"; then
4116      ac_exists=true
4117      break
4118    fi
4119  done
4120
4121  if test x"$ac_exists" = xtrue; then
4122  :
4123 else
4124  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4125 fi
4126
4127          ;;
4128       # Other files - we have no idea how they are generated
4129       *)
4130          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
4131 echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
4132          ;;
4133   esac
4134 done
4135 if test "x$ac_cv_f90_module_names" = "x"; then
4136  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4137 echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4138 fi
4139
4140 else
10380    echo "$as_me: failed program was:" >&5
10381   sed 's/^/| /' conftest.$ac_ext >&5
10382  
10383 < ac_cv_f90_module_names=
4145 < { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4146 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
10383 > ac_cv_cxx_namespaces=no
10384   fi
10385 < rm -f conftest.$ac_objext conftest.$ac_ext
10386 < cd ..
10387 < # cleanup
10388 < rm -rf conftest
10389 < ac_ext=f90
10390 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4154 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4155 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
10385 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10386 > ac_ext=cc
10387 > ac_cpp='$CXXCPP $CPPFLAGS'
10388 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10389 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10390 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10391  
4157 fi
4158 echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
4159 echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
10392  
4161 # We now generate a shell script that will help us to figure out the correct
4162 # module file names, using the value of ac_cv_f90_module_names
4163
4164 echo "Generating shell script modnam"
4165
4166 cat > scripts/modnam << EOF
4167 #! /bin/sh
4168 # This script is auto-generated by configure
4169 #
4170 usage="\\
4171 Usage: \$0 [FILES]
4172
4173 [FILES] are Fortran 90 source files.
4174 The output is a list of module file names that the Fortran 90 compiler
4175 generates when compiling [FILES]."
4176
4177 list=
4178 empty=
4179
4180 if test \$# -eq 0; then
4181   echo "\$usage"; exit 0
10393   fi
10394 + echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10395 + echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10396 + if test "$ac_cv_cxx_namespaces" = yes; then
10397  
10398 < while test \$# != 0; do
10398 > cat >>confdefs.h <<\_ACEOF
10399 > #define HAVE_NAMESPACES
10400 > _ACEOF
10401  
4186  file=\$1
4187  shift
4188
4189 # strip suffix
4190  base=\`echo \$file | sed 's/[.][^.]*$//'\`
4191
4192  test ! -f \$file && continue
4193
4194 # Look for module definitions and transform them to upper / lower case
4195  mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
4196  upper=\`echo \$mods | tr a-z A-Z\`
4197  lower=\`echo \$mods | tr A-Z a-z\`
4198
4199 # Here, the patterns for generating module file names were inserted by configure
4200  for trans in $ac_cv_f90_module_names; do
4201
4202    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
4203    var=empty
4204    case \$pat in
4205       %MODULE%)
4206          var=upper ;;
4207       %Module%)
4208          var=mods ;;
4209       %module%)
4210          var=lower ;;
4211       %FILE%)
4212          test -n "\$mods" && var=base ;;
4213    esac
4214    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
4215    list="\$list \$new"
4216  done
4217 done
4218
4219 echo \$list
4220 # end of configure-generated script
4221 EOF
4222 chmod 755 scripts/modnam
4223
4224 pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
4225 F90_MODULE_NAMES=empty
4226 case $pat in
4227       %MODULE%)
4228          F90_MODULE_NAMES=UPPER ;;
4229       %Module%)
4230          F90_MODULE_NAMES=Mixed ;;
4231       %module%)
4232          F90_MODULE_NAMES=lower ;;
4233       *)
4234          F90_MODULE_NAMES=unknown ;;
4235 esac
4236
4237 ac_ext=c
4238 ac_cpp='$CPP $CPPFLAGS'
4239 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4240 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4241 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4242
4243
4244 ac_ext=c
4245 ac_cpp='$CPP $CPPFLAGS'
4246 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4247 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4248 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4249
4250 ac_ext=c
4251 ac_cpp='$CPP $CPPFLAGS'
4252 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4253 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4254 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4255 echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4256 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4257 # On Suns, sometimes $CPP names a directory.
4258 if test -n "$CPP" && test -d "$CPP"; then
4259  CPP=
10402   fi
10403 < if test -z "$CPP"; then
10404 <  if test "${ac_cv_prog_CPP+set}" = set; then
10403 >
10404 > ac_ext=cc
10405 > ac_cpp='$CXXCPP $CPPFLAGS'
10406 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10407 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10408 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10409 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10410 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10411 > if test -z "$CXXCPP"; then
10412 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10413    echo $ECHO_N "(cached) $ECHO_C" >&6
10414   else
10415 <      # Double quotes because CPP needs to be expanded
10416 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
10415 >      # Double quotes because CXXCPP needs to be expanded
10416 >    for CXXCPP in "$CXX -E" "/lib/cpp"
10417      do
10418        ac_preproc_ok=false
10419 < for ac_c_preproc_warn_flag in '' yes
10419 > for ac_cxx_preproc_warn_flag in '' yes
10420   do
10421    # Use a header file that comes with gcc, so configuring glibc
10422    # with a fresh cross-compiler works.
# Line 4275 | Line 10425 | do
10425    # On the NeXT, cc -E runs the code through the compiler's parser,
10426    # not just through cpp. "Syntax error" is here to catch this case.
10427    cat >conftest.$ac_ext <<_ACEOF
4278 #line $LINENO "configure"
10428   /* confdefs.h.  */
10429   _ACEOF
10430   cat confdefs.h >>conftest.$ac_ext
# Line 4286 | Line 10435 | cat >>conftest.$ac_ext <<_ACEOF
10435   #else
10436   # include <assert.h>
10437   #endif
10438 <                     Syntax error
10438 >                     Syntax error
10439   _ACEOF
10440   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10441    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 4297 | Line 10446 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10446    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10447    (exit $ac_status); } >/dev/null; then
10448    if test -s conftest.err; then
10449 <    ac_cpp_err=$ac_c_preproc_warn_flag
10449 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10450 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10451    else
10452      ac_cpp_err=
10453    fi
# Line 4318 | Line 10468 | rm -f conftest.err conftest.$ac_ext
10468    # OK, works on sane cases.  Now check whether non-existent headers
10469    # can be detected and how.
10470    cat >conftest.$ac_ext <<_ACEOF
4321 #line $LINENO "configure"
10471   /* confdefs.h.  */
10472   _ACEOF
10473   cat confdefs.h >>conftest.$ac_ext
# Line 4335 | Line 10484 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10484    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10485    (exit $ac_status); } >/dev/null; then
10486    if test -s conftest.err; then
10487 <    ac_cpp_err=$ac_c_preproc_warn_flag
10487 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10488 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10489    else
10490      ac_cpp_err=
10491    fi
# Line 4363 | Line 10513 | fi
10513   fi
10514  
10515      done
10516 <    ac_cv_prog_CPP=$CPP
10516 >    ac_cv_prog_CXXCPP=$CXXCPP
10517  
10518   fi
10519 <  CPP=$ac_cv_prog_CPP
10519 >  CXXCPP=$ac_cv_prog_CXXCPP
10520   else
10521 <  ac_cv_prog_CPP=$CPP
10521 >  ac_cv_prog_CXXCPP=$CXXCPP
10522   fi
10523 < echo "$as_me:$LINENO: result: $CPP" >&5
10524 < echo "${ECHO_T}$CPP" >&6
10523 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10524 > echo "${ECHO_T}$CXXCPP" >&6
10525   ac_preproc_ok=false
10526 < for ac_c_preproc_warn_flag in '' yes
10526 > for ac_cxx_preproc_warn_flag in '' yes
10527   do
10528    # Use a header file that comes with gcc, so configuring glibc
10529    # with a fresh cross-compiler works.
# Line 4382 | Line 10532 | do
10532    # On the NeXT, cc -E runs the code through the compiler's parser,
10533    # not just through cpp. "Syntax error" is here to catch this case.
10534    cat >conftest.$ac_ext <<_ACEOF
4385 #line $LINENO "configure"
10535   /* confdefs.h.  */
10536   _ACEOF
10537   cat confdefs.h >>conftest.$ac_ext
# Line 4393 | Line 10542 | cat >>conftest.$ac_ext <<_ACEOF
10542   #else
10543   # include <assert.h>
10544   #endif
10545 <                     Syntax error
10545 >                     Syntax error
10546   _ACEOF
10547   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10548    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 4404 | Line 10553 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10553    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10554    (exit $ac_status); } >/dev/null; then
10555    if test -s conftest.err; then
10556 <    ac_cpp_err=$ac_c_preproc_warn_flag
10556 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10557 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10558    else
10559      ac_cpp_err=
10560    fi
# Line 4425 | Line 10575 | rm -f conftest.err conftest.$ac_ext
10575    # OK, works on sane cases.  Now check whether non-existent headers
10576    # can be detected and how.
10577    cat >conftest.$ac_ext <<_ACEOF
4428 #line $LINENO "configure"
10578   /* confdefs.h.  */
10579   _ACEOF
10580   cat confdefs.h >>conftest.$ac_ext
# Line 4442 | Line 10591 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10591    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10592    (exit $ac_status); } >/dev/null; then
10593    if test -s conftest.err; then
10594 <    ac_cpp_err=$ac_c_preproc_warn_flag
10594 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10595 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10596    else
10597      ac_cpp_err=
10598    fi
# Line 4468 | Line 10618 | else
10618   if $ac_preproc_ok; then
10619    :
10620   else
10621 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
10621 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10622   See \`config.log' for more details." >&5
10623 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
10623 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10624   See \`config.log' for more details." >&2;}
10625     { (exit 1); exit 1; }; }
10626   fi
10627  
10628 < ac_ext=c
10629 < ac_cpp='$CPP $CPPFLAGS'
10630 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10631 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10632 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4483 <
4484 <
4485 < echo "$as_me:$LINENO: checking for egrep" >&5
4486 < echo $ECHO_N "checking for egrep... $ECHO_C" >&6
4487 < 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
4494 < fi
4495 < echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
4496 < echo "${ECHO_T}$ac_cv_prog_egrep" >&6
4497 < EGREP=$ac_cv_prog_egrep
10628 > ac_ext=cc
10629 > ac_cpp='$CXXCPP $CPPFLAGS'
10630 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10631 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10632 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10633  
10634  
10635 < echo "$as_me:$LINENO: checking for ANSI C header files" >&5
10636 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
10637 < if test "${ac_cv_header_stdc+set}" = set; then
10635 > echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10636 > echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10637 > if test "${ac_cv_cxx_have_stl+set}" = set; then
10638    echo $ECHO_N "(cached) $ECHO_C" >&6
10639   else
10640 <  cat >conftest.$ac_ext <<_ACEOF
10641 < #line $LINENO "configure"
10640 >
10641 >
10642 >
10643 > ac_ext=cc
10644 > ac_cpp='$CXXCPP $CPPFLAGS'
10645 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10646 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10647 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10648 >
10649 > cat >conftest.$ac_ext <<_ACEOF
10650   /* confdefs.h.  */
10651   _ACEOF
10652   cat confdefs.h >>conftest.$ac_ext
10653   cat >>conftest.$ac_ext <<_ACEOF
10654   /* end confdefs.h.  */
10655 < #include <stdlib.h>
10656 < #include <stdarg.h>
10657 < #include <string.h>
10658 < #include <float.h>
10659 <
10655 > #include <list>
10656 > #include <deque>
10657 > #ifdef HAVE_NAMESPACES
10658 > using namespace std;
10659 > #endif
10660 > #ifdef FC_DUMMY_MAIN
10661 > #ifndef FC_DUMMY_MAIN_EQ_F77
10662 > #  ifdef __cplusplus
10663 >     extern "C"
10664 > #  endif
10665 >   int FC_DUMMY_MAIN() { return 1; }
10666 > #endif
10667 > #endif
10668   int
10669   main ()
10670   {
10671 <
10671 > list<int> x; x.push_back(5);
10672 > list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10673    ;
10674    return 0;
10675   }
10676 + _ACEOF
10677 + rm -f conftest.$ac_objext
10678 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10679 +  (eval $ac_compile) 2>conftest.er1
10680 +  ac_status=$?
10681 +  grep -v '^ *+' conftest.er1 >conftest.err
10682 +  rm -f conftest.er1
10683 +  cat conftest.err >&5
10684 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10685 +  (exit $ac_status); } &&
10686 +         { ac_try='test -z "$ac_cxx_werror_flag"
10687 +                         || test ! -s conftest.err'
10688 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10689 +  (eval $ac_try) 2>&5
10690 +  ac_status=$?
10691 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10692 +  (exit $ac_status); }; } &&
10693 +         { ac_try='test -s conftest.$ac_objext'
10694 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10695 +  (eval $ac_try) 2>&5
10696 +  ac_status=$?
10697 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10698 +  (exit $ac_status); }; }; then
10699 +  ac_cv_cxx_have_stl=yes
10700 + else
10701 +  echo "$as_me: failed program was:" >&5
10702 + sed 's/^/| /' conftest.$ac_ext >&5
10703 +
10704 + ac_cv_cxx_have_stl=no
10705 + fi
10706 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10707 + ac_ext=cc
10708 + ac_cpp='$CXXCPP $CPPFLAGS'
10709 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10710 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10711 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10712 +
10713 +
10714 + fi
10715 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10716 + echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10717 + if test "$ac_cv_cxx_have_stl" = yes; then
10718 +
10719 + cat >>confdefs.h <<\_ACEOF
10720 + #define HAVE_STL
10721   _ACEOF
10722 +
10723 + fi
10724 +
10725 +
10726 +
10727 +  if test "${ac_cv_header_iostream+set}" = set; then
10728 +  echo "$as_me:$LINENO: checking for iostream" >&5
10729 + echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10730 + if test "${ac_cv_header_iostream+set}" = set; then
10731 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10732 + fi
10733 + echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10734 + echo "${ECHO_T}$ac_cv_header_iostream" >&6
10735 + else
10736 +  # Is the header compilable?
10737 + echo "$as_me:$LINENO: checking iostream usability" >&5
10738 + echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10739 + cat >conftest.$ac_ext <<_ACEOF
10740 + /* confdefs.h.  */
10741 + _ACEOF
10742 + cat confdefs.h >>conftest.$ac_ext
10743 + cat >>conftest.$ac_ext <<_ACEOF
10744 + /* end confdefs.h.  */
10745 + $ac_includes_default
10746 + #include <iostream>
10747 + _ACEOF
10748   rm -f conftest.$ac_objext
10749 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10750 <  (eval $ac_compile) 2>&5
10749 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10750 >  (eval $ac_compile) 2>conftest.er1
10751 >  ac_status=$?
10752 >  grep -v '^ *+' conftest.er1 >conftest.err
10753 >  rm -f conftest.er1
10754 >  cat conftest.err >&5
10755 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10756 >  (exit $ac_status); } &&
10757 >         { ac_try='test -z "$ac_cxx_werror_flag"
10758 >                         || test ! -s conftest.err'
10759 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10760 >  (eval $ac_try) 2>&5
10761 >  ac_status=$?
10762 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10763 >  (exit $ac_status); }; } &&
10764 >         { ac_try='test -s conftest.$ac_objext'
10765 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10766 >  (eval $ac_try) 2>&5
10767 >  ac_status=$?
10768 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10769 >  (exit $ac_status); }; }; then
10770 >  ac_header_compiler=yes
10771 > else
10772 >  echo "$as_me: failed program was:" >&5
10773 > sed 's/^/| /' conftest.$ac_ext >&5
10774 >
10775 > ac_header_compiler=no
10776 > fi
10777 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10778 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10779 > echo "${ECHO_T}$ac_header_compiler" >&6
10780 >
10781 > # Is the header present?
10782 > echo "$as_me:$LINENO: checking iostream presence" >&5
10783 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10784 > cat >conftest.$ac_ext <<_ACEOF
10785 > /* confdefs.h.  */
10786 > _ACEOF
10787 > cat confdefs.h >>conftest.$ac_ext
10788 > cat >>conftest.$ac_ext <<_ACEOF
10789 > /* end confdefs.h.  */
10790 > #include <iostream>
10791 > _ACEOF
10792 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10793 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10794 >  ac_status=$?
10795 >  grep -v '^ *+' conftest.er1 >conftest.err
10796 >  rm -f conftest.er1
10797 >  cat conftest.err >&5
10798 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10799 >  (exit $ac_status); } >/dev/null; then
10800 >  if test -s conftest.err; then
10801 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10802 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10803 >  else
10804 >    ac_cpp_err=
10805 >  fi
10806 > else
10807 >  ac_cpp_err=yes
10808 > fi
10809 > if test -z "$ac_cpp_err"; then
10810 >  ac_header_preproc=yes
10811 > else
10812 >  echo "$as_me: failed program was:" >&5
10813 > sed 's/^/| /' conftest.$ac_ext >&5
10814 >
10815 >  ac_header_preproc=no
10816 > fi
10817 > rm -f conftest.err conftest.$ac_ext
10818 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10819 > echo "${ECHO_T}$ac_header_preproc" >&6
10820 >
10821 > # So?  What about this header?
10822 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10823 >  yes:no: )
10824 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10825 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10826 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10827 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10828 >    ac_header_preproc=yes
10829 >    ;;
10830 >  no:yes:* )
10831 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10832 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10833 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10834 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10835 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10836 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10837 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10838 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10839 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10840 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10841 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10842 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10843 >    (
10844 >      cat <<\_ASBOX
10845 > ## ------------------------------ ##
10846 > ## Report this to gezelter@nd.edu ##
10847 > ## ------------------------------ ##
10848 > _ASBOX
10849 >    ) |
10850 >      sed "s/^/$as_me: WARNING:     /" >&2
10851 >    ;;
10852 > esac
10853 > echo "$as_me:$LINENO: checking for iostream" >&5
10854 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10855 > if test "${ac_cv_header_iostream+set}" = set; then
10856 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10857 > else
10858 >  ac_cv_header_iostream=$ac_header_preproc
10859 > fi
10860 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10861 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10862 >
10863 > fi
10864 > if test $ac_cv_header_iostream = yes; then
10865 >
10866 >
10867 > cat >>confdefs.h <<\_ACEOF
10868 > #define HAVE_IOSTREAM 1
10869 > _ACEOF
10870 >
10871 >
10872 > else
10873 >
10874 >
10875 > for ac_header in iostream.h
10876 > do
10877 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10878 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10879 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10880 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10881 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10882 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10883 > fi
10884 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10885 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10886 > else
10887 >  # Is the header compilable?
10888 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10889 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10890 > cat >conftest.$ac_ext <<_ACEOF
10891 > /* confdefs.h.  */
10892 > _ACEOF
10893 > cat confdefs.h >>conftest.$ac_ext
10894 > cat >>conftest.$ac_ext <<_ACEOF
10895 > /* end confdefs.h.  */
10896 > $ac_includes_default
10897 > #include <$ac_header>
10898 > _ACEOF
10899 > rm -f conftest.$ac_objext
10900 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10901 >  (eval $ac_compile) 2>conftest.er1
10902 >  ac_status=$?
10903 >  grep -v '^ *+' conftest.er1 >conftest.err
10904 >  rm -f conftest.er1
10905 >  cat conftest.err >&5
10906 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10907 >  (exit $ac_status); } &&
10908 >         { ac_try='test -z "$ac_cxx_werror_flag"
10909 >                         || test ! -s conftest.err'
10910 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10911 >  (eval $ac_try) 2>&5
10912 >  ac_status=$?
10913 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10914 >  (exit $ac_status); }; } &&
10915 >         { ac_try='test -s conftest.$ac_objext'
10916 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10917 >  (eval $ac_try) 2>&5
10918 >  ac_status=$?
10919 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10920 >  (exit $ac_status); }; }; then
10921 >  ac_header_compiler=yes
10922 > else
10923 >  echo "$as_me: failed program was:" >&5
10924 > sed 's/^/| /' conftest.$ac_ext >&5
10925 >
10926 > ac_header_compiler=no
10927 > fi
10928 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10929 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10930 > echo "${ECHO_T}$ac_header_compiler" >&6
10931 >
10932 > # Is the header present?
10933 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10934 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10935 > cat >conftest.$ac_ext <<_ACEOF
10936 > /* confdefs.h.  */
10937 > _ACEOF
10938 > cat confdefs.h >>conftest.$ac_ext
10939 > cat >>conftest.$ac_ext <<_ACEOF
10940 > /* end confdefs.h.  */
10941 > #include <$ac_header>
10942 > _ACEOF
10943 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10944 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10945 >  ac_status=$?
10946 >  grep -v '^ *+' conftest.er1 >conftest.err
10947 >  rm -f conftest.er1
10948 >  cat conftest.err >&5
10949 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10950 >  (exit $ac_status); } >/dev/null; then
10951 >  if test -s conftest.err; then
10952 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10953 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10954 >  else
10955 >    ac_cpp_err=
10956 >  fi
10957 > else
10958 >  ac_cpp_err=yes
10959 > fi
10960 > if test -z "$ac_cpp_err"; then
10961 >  ac_header_preproc=yes
10962 > else
10963 >  echo "$as_me: failed program was:" >&5
10964 > sed 's/^/| /' conftest.$ac_ext >&5
10965 >
10966 >  ac_header_preproc=no
10967 > fi
10968 > rm -f conftest.err conftest.$ac_ext
10969 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10970 > echo "${ECHO_T}$ac_header_preproc" >&6
10971 >
10972 > # So?  What about this header?
10973 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10974 >  yes:no: )
10975 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10976 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10977 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10978 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10979 >    ac_header_preproc=yes
10980 >    ;;
10981 >  no:yes:* )
10982 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10983 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10984 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10985 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10986 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10987 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10988 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10989 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10990 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10991 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10992 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10993 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10994 >    (
10995 >      cat <<\_ASBOX
10996 > ## ------------------------------ ##
10997 > ## Report this to gezelter@nd.edu ##
10998 > ## ------------------------------ ##
10999 > _ASBOX
11000 >    ) |
11001 >      sed "s/^/$as_me: WARNING:     /" >&2
11002 >    ;;
11003 > esac
11004 > echo "$as_me:$LINENO: checking for $ac_header" >&5
11005 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11006 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11007 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11008 > else
11009 >  eval "$as_ac_Header=\$ac_header_preproc"
11010 > fi
11011 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11012 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11013 >
11014 > fi
11015 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
11016 >  cat >>confdefs.h <<_ACEOF
11017 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11018 > _ACEOF
11019 >
11020 > fi
11021 >
11022 > done
11023 >
11024 >
11025 > fi
11026 >
11027 >
11028 >
11029 >
11030 >  if test "${ac_cv_header_iomanip+set}" = set; then
11031 >  echo "$as_me:$LINENO: checking for iomanip" >&5
11032 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
11033 > if test "${ac_cv_header_iomanip+set}" = set; then
11034 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11035 > fi
11036 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
11037 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
11038 > else
11039 >  # Is the header compilable?
11040 > echo "$as_me:$LINENO: checking iomanip usability" >&5
11041 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
11042 > cat >conftest.$ac_ext <<_ACEOF
11043 > /* confdefs.h.  */
11044 > _ACEOF
11045 > cat confdefs.h >>conftest.$ac_ext
11046 > cat >>conftest.$ac_ext <<_ACEOF
11047 > /* end confdefs.h.  */
11048 > $ac_includes_default
11049 > #include <iomanip>
11050 > _ACEOF
11051 > rm -f conftest.$ac_objext
11052 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11053 >  (eval $ac_compile) 2>conftest.er1
11054 >  ac_status=$?
11055 >  grep -v '^ *+' conftest.er1 >conftest.err
11056 >  rm -f conftest.er1
11057 >  cat conftest.err >&5
11058 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11059 >  (exit $ac_status); } &&
11060 >         { ac_try='test -z "$ac_cxx_werror_flag"
11061 >                         || test ! -s conftest.err'
11062 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11063 >  (eval $ac_try) 2>&5
11064    ac_status=$?
11065    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11066 <  (exit $ac_status); } &&
11067 <         { ac_try='test -s conftest.$ac_objext'
11066 >  (exit $ac_status); }; } &&
11067 >         { ac_try='test -s conftest.$ac_objext'
11068    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11069    (eval $ac_try) 2>&5
11070    ac_status=$?
11071    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11072    (exit $ac_status); }; }; then
11073 <  ac_cv_header_stdc=yes
11073 >  ac_header_compiler=yes
11074   else
11075    echo "$as_me: failed program was:" >&5
11076   sed 's/^/| /' conftest.$ac_ext >&5
11077  
11078 < ac_cv_header_stdc=no
11078 > ac_header_compiler=no
11079   fi
11080 < rm -f conftest.$ac_objext conftest.$ac_ext
11080 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11081 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11082 > echo "${ECHO_T}$ac_header_compiler" >&6
11083  
11084 < if test $ac_cv_header_stdc = yes; then
11085 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
11086 <  cat >conftest.$ac_ext <<_ACEOF
11087 < #line $LINENO "configure"
11084 > # Is the header present?
11085 > echo "$as_me:$LINENO: checking iomanip presence" >&5
11086 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
11087 > cat >conftest.$ac_ext <<_ACEOF
11088   /* confdefs.h.  */
11089   _ACEOF
11090   cat confdefs.h >>conftest.$ac_ext
11091   cat >>conftest.$ac_ext <<_ACEOF
11092   /* end confdefs.h.  */
11093 < #include <string.h>
4556 <
11093 > #include <iomanip>
11094   _ACEOF
11095 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
11096 <  $EGREP "memchr" >/dev/null 2>&1; then
11097 <  :
11095 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11096 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11097 >  ac_status=$?
11098 >  grep -v '^ *+' conftest.er1 >conftest.err
11099 >  rm -f conftest.er1
11100 >  cat conftest.err >&5
11101 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11102 >  (exit $ac_status); } >/dev/null; then
11103 >  if test -s conftest.err; then
11104 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11105 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11106 >  else
11107 >    ac_cpp_err=
11108 >  fi
11109   else
11110 <  ac_cv_header_stdc=no
11110 >  ac_cpp_err=yes
11111   fi
11112 < rm -f conftest*
11112 > if test -z "$ac_cpp_err"; then
11113 >  ac_header_preproc=yes
11114 > else
11115 >  echo "$as_me: failed program was:" >&5
11116 > sed 's/^/| /' conftest.$ac_ext >&5
11117  
11118 +  ac_header_preproc=no
11119   fi
11120 + rm -f conftest.err conftest.$ac_ext
11121 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11122 + echo "${ECHO_T}$ac_header_preproc" >&6
11123  
11124 < if test $ac_cv_header_stdc = yes; then
11125 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
11126 <  cat >conftest.$ac_ext <<_ACEOF
11127 < #line $LINENO "configure"
11128 < /* confdefs.h.  */
11129 < _ACEOF
11130 < cat confdefs.h >>conftest.$ac_ext
11131 < cat >>conftest.$ac_ext <<_ACEOF
11132 < /* end confdefs.h.  */
11133 < #include <stdlib.h>
11134 <
11135 < _ACEOF
11136 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
11137 <  $EGREP "free" >/dev/null 2>&1; then
11138 <  :
11124 > # So?  What about this header?
11125 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11126 >  yes:no: )
11127 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
11128 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
11129 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
11130 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
11131 >    ac_header_preproc=yes
11132 >    ;;
11133 >  no:yes:* )
11134 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
11135 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
11136 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
11137 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
11138 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
11139 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
11140 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
11141 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
11142 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
11143 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
11144 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
11145 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
11146 >    (
11147 >      cat <<\_ASBOX
11148 > ## ------------------------------ ##
11149 > ## Report this to gezelter@nd.edu ##
11150 > ## ------------------------------ ##
11151 > _ASBOX
11152 >    ) |
11153 >      sed "s/^/$as_me: WARNING:     /" >&2
11154 >    ;;
11155 > esac
11156 > echo "$as_me:$LINENO: checking for iomanip" >&5
11157 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
11158 > if test "${ac_cv_header_iomanip+set}" = set; then
11159 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11160   else
11161 <  ac_cv_header_stdc=no
11161 >  ac_cv_header_iomanip=$ac_header_preproc
11162   fi
11163 < rm -f conftest*
11163 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
11164 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
11165  
11166   fi
11167 + if test $ac_cv_header_iomanip = yes; then
11168  
4590 if test $ac_cv_header_stdc = yes; then
4591  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
4592  if test "$cross_compiling" = yes; then
4593  :
4594 else
4595  cat >conftest.$ac_ext <<_ACEOF
4596 #line $LINENO "configure"
4597 /* confdefs.h.  */
4598 _ACEOF
4599 cat confdefs.h >>conftest.$ac_ext
4600 cat >>conftest.$ac_ext <<_ACEOF
4601 /* end confdefs.h.  */
4602 #include <ctype.h>
4603 #if ((' ' & 0x0FF) == 0x020)
4604 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4605 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
4606 #else
4607 # define ISLOWER(c) \
4608                   (('a' <= (c) && (c) <= 'i') \
4609                     || ('j' <= (c) && (c) <= 'r') \
4610                     || ('s' <= (c) && (c) <= 'z'))
4611 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
4612 #endif
11169  
4614 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
4615 int
4616 main ()
4617 {
4618  int i;
4619  for (i = 0; i < 256; i++)
4620    if (XOR (islower (i), ISLOWER (i))
4621        || toupper (i) != TOUPPER (i))
4622      exit(2);
4623  exit (0);
4624 }
4625 _ACEOF
4626 rm -f conftest$ac_exeext
4627 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4628  (eval $ac_link) 2>&5
4629  ac_status=$?
4630  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4631  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
4632  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4633  (eval $ac_try) 2>&5
4634  ac_status=$?
4635  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4636  (exit $ac_status); }; }; then
4637  :
4638 else
4639  echo "$as_me: program exited with status $ac_status" >&5
4640 echo "$as_me: failed program was:" >&5
4641 sed 's/^/| /' conftest.$ac_ext >&5
4642
4643 ( exit $ac_status )
4644 ac_cv_header_stdc=no
4645 fi
4646 rm -f core core.* *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
4647 fi
4648 fi
4649 fi
4650 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
4653
11170   cat >>confdefs.h <<\_ACEOF
11171 < #define STDC_HEADERS 1
11171 > #define HAVE_IOMANIP 1
11172   _ACEOF
11173  
4658 fi
11174  
11175 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
11175 > else
11176  
11177  
11178 <
4664 <
4665 <
4666 <
4667 <
4668 <
4669 <
4670 < 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
11178 > for ac_header in iomanip.h
11179   do
11180   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11181 < echo "$as_me:$LINENO: checking for $ac_header" >&5
11181 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11182 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
11183   echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11184   if eval "test \"\${$as_ac_Header+set}\" = set"; then
11185    echo $ECHO_N "(cached) $ECHO_C" >&6
11186 + fi
11187 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11188 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11189   else
11190 <  cat >conftest.$ac_ext <<_ACEOF
11191 < #line $LINENO "configure"
11190 >  # Is the header compilable?
11191 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
11192 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11193 > cat >conftest.$ac_ext <<_ACEOF
11194   /* confdefs.h.  */
11195   _ACEOF
11196   cat confdefs.h >>conftest.$ac_ext
11197   cat >>conftest.$ac_ext <<_ACEOF
11198   /* end confdefs.h.  */
11199   $ac_includes_default
4687
11200   #include <$ac_header>
11201   _ACEOF
11202   rm -f conftest.$ac_objext
11203   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11204 <  (eval $ac_compile) 2>&5
11204 >  (eval $ac_compile) 2>conftest.er1
11205    ac_status=$?
11206 +  grep -v '^ *+' conftest.er1 >conftest.err
11207 +  rm -f conftest.er1
11208 +  cat conftest.err >&5
11209    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11210    (exit $ac_status); } &&
11211 <         { ac_try='test -s conftest.$ac_objext'
11211 >         { ac_try='test -z "$ac_cxx_werror_flag"
11212 >                         || test ! -s conftest.err'
11213    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11214    (eval $ac_try) 2>&5
11215    ac_status=$?
11216    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11217 +  (exit $ac_status); }; } &&
11218 +         { ac_try='test -s conftest.$ac_objext'
11219 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11220 +  (eval $ac_try) 2>&5
11221 +  ac_status=$?
11222 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11223    (exit $ac_status); }; }; then
11224 <  eval "$as_ac_Header=yes"
11224 >  ac_header_compiler=yes
11225   else
11226    echo "$as_me: failed program was:" >&5
11227   sed 's/^/| /' conftest.$ac_ext >&5
11228  
11229 < eval "$as_ac_Header=no"
11229 > ac_header_compiler=no
11230   fi
11231 < rm -f conftest.$ac_objext conftest.$ac_ext
11231 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11232 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11233 > echo "${ECHO_T}$ac_header_compiler" >&6
11234 >
11235 > # Is the header present?
11236 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
11237 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11238 > cat >conftest.$ac_ext <<_ACEOF
11239 > /* confdefs.h.  */
11240 > _ACEOF
11241 > cat confdefs.h >>conftest.$ac_ext
11242 > cat >>conftest.$ac_ext <<_ACEOF
11243 > /* end confdefs.h.  */
11244 > #include <$ac_header>
11245 > _ACEOF
11246 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11247 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11248 >  ac_status=$?
11249 >  grep -v '^ *+' conftest.er1 >conftest.err
11250 >  rm -f conftest.er1
11251 >  cat conftest.err >&5
11252 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11253 >  (exit $ac_status); } >/dev/null; then
11254 >  if test -s conftest.err; then
11255 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11256 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11257 >  else
11258 >    ac_cpp_err=
11259 >  fi
11260 > else
11261 >  ac_cpp_err=yes
11262 > fi
11263 > if test -z "$ac_cpp_err"; then
11264 >  ac_header_preproc=yes
11265 > else
11266 >  echo "$as_me: failed program was:" >&5
11267 > sed 's/^/| /' conftest.$ac_ext >&5
11268 >
11269 >  ac_header_preproc=no
11270   fi
11271 + rm -f conftest.err conftest.$ac_ext
11272 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11273 + echo "${ECHO_T}$ac_header_preproc" >&6
11274 +
11275 + # So?  What about this header?
11276 + case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11277 +  yes:no: )
11278 +    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11279 + echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11280 +    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11281 + echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11282 +    ac_header_preproc=yes
11283 +    ;;
11284 +  no:yes:* )
11285 +    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11286 + echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11287 +    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11288 + echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11289 +    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11290 + echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11291 +    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11292 + echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11293 +    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11294 + echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11295 +    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11296 + echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11297 +    (
11298 +      cat <<\_ASBOX
11299 + ## ------------------------------ ##
11300 + ## Report this to gezelter@nd.edu ##
11301 + ## ------------------------------ ##
11302 + _ASBOX
11303 +    ) |
11304 +      sed "s/^/$as_me: WARNING:     /" >&2
11305 +    ;;
11306 + esac
11307 + echo "$as_me:$LINENO: checking for $ac_header" >&5
11308 + echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11309 + if eval "test \"\${$as_ac_Header+set}\" = set"; then
11310 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11311 + else
11312 +  eval "$as_ac_Header=\$ac_header_preproc"
11313 + fi
11314   echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11315   echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11316 +
11317 + fi
11318   if test `eval echo '${'$as_ac_Header'}'` = yes; then
11319    cat >>confdefs.h <<_ACEOF
11320   #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
# Line 4720 | Line 11325 | done
11325   done
11326  
11327  
11328 + fi
11329  
11330  
11331  
11332  
11333 <
4728 <
4729 <
4730 <
4731 <
4732 < for ac_header in unistd.h sys/pstat.h sys/sysmp.h sys/sysinfo.h sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h machine/hal_sysinfo.h
11333 > for ac_header in cmath
11334   do
11335   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11336   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 4745 | Line 11346 | cat >conftest.$ac_ext <<_ACEOF
11346   echo "$as_me:$LINENO: checking $ac_header usability" >&5
11347   echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11348   cat >conftest.$ac_ext <<_ACEOF
4748 #line $LINENO "configure"
11349   /* confdefs.h.  */
11350   _ACEOF
11351   cat confdefs.h >>conftest.$ac_ext
# Line 4756 | Line 11356 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11356   _ACEOF
11357   rm -f conftest.$ac_objext
11358   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11359 <  (eval $ac_compile) 2>&5
11359 >  (eval $ac_compile) 2>conftest.er1
11360    ac_status=$?
11361 +  grep -v '^ *+' conftest.er1 >conftest.err
11362 +  rm -f conftest.er1
11363 +  cat conftest.err >&5
11364    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11365    (exit $ac_status); } &&
11366 <         { ac_try='test -s conftest.$ac_objext'
11366 >         { ac_try='test -z "$ac_cxx_werror_flag"
11367 >                         || test ! -s conftest.err'
11368    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11369    (eval $ac_try) 2>&5
11370    ac_status=$?
11371    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11372 +  (exit $ac_status); }; } &&
11373 +         { ac_try='test -s conftest.$ac_objext'
11374 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11375 +  (eval $ac_try) 2>&5
11376 +  ac_status=$?
11377 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11378    (exit $ac_status); }; }; then
11379    ac_header_compiler=yes
11380   else
# Line 4773 | Line 11383 | fi
11383  
11384   ac_header_compiler=no
11385   fi
11386 < rm -f conftest.$ac_objext conftest.$ac_ext
11386 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11387   echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11388   echo "${ECHO_T}$ac_header_compiler" >&6
11389  
# Line 4781 | Line 11391 | cat >conftest.$ac_ext <<_ACEOF
11391   echo "$as_me:$LINENO: checking $ac_header presence" >&5
11392   echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11393   cat >conftest.$ac_ext <<_ACEOF
4784 #line $LINENO "configure"
11394   /* confdefs.h.  */
11395   _ACEOF
11396   cat confdefs.h >>conftest.$ac_ext
# Line 4798 | Line 11407 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11407    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11408    (exit $ac_status); } >/dev/null; then
11409    if test -s conftest.err; then
11410 <    ac_cpp_err=$ac_c_preproc_warn_flag
11410 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11411 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11412    else
11413      ac_cpp_err=
11414    fi
# Line 4818 | Line 11428 | echo "${ECHO_T}$ac_header_preproc" >&6
11428   echo "${ECHO_T}$ac_header_preproc" >&6
11429  
11430   # So?  What about this header?
11431 < case $ac_header_compiler:$ac_header_preproc in
11432 <  yes:no )
11431 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11432 >  yes:no: )
11433      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11434   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11435 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11436 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11437 <    (
4828 <      cat <<\_ASBOX
4829 < ## ------------------------------------ ##
4830 < ## Report this to bug-autoconf@gnu.org. ##
4831 < ## ------------------------------------ ##
4832 < _ASBOX
4833 <    ) |
4834 <      sed "s/^/$as_me: WARNING:     /" >&2
11435 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11436 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11437 >    ac_header_preproc=yes
11438      ;;
11439 <  no:yes )
11439 >  no:yes:* )
11440      { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11441   echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11442 <    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
11443 < echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
11442 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11443 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11444 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11445 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11446 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11447 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11448      { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11449   echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11450 +    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11451 + echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11452      (
11453        cat <<\_ASBOX
11454 < ## ------------------------------------ ##
11455 < ## Report this to bug-autoconf@gnu.org. ##
11456 < ## ------------------------------------ ##
11454 > ## ------------------------------ ##
11455 > ## Report this to gezelter@nd.edu ##
11456 > ## ------------------------------ ##
11457   _ASBOX
11458      ) |
11459        sed "s/^/$as_me: WARNING:     /" >&2
# Line 4855 | Line 11464 | else
11464   if eval "test \"\${$as_ac_Header+set}\" = set"; then
11465    echo $ECHO_N "(cached) $ECHO_C" >&6
11466   else
11467 <  eval "$as_ac_Header=$ac_header_preproc"
11467 >  eval "$as_ac_Header=\$ac_header_preproc"
11468   fi
11469   echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11470   echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
# Line 4873 | Line 11482 | done
11482  
11483  
11484  
11485 <
11486 <
11487 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
4879 < do
4880 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
4881 < echo "$as_me:$LINENO: checking for $ac_func" >&5
4882 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
4883 < if eval "test \"\${$as_ac_var+set}\" = set"; then
11485 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11486 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11487 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11488    echo $ECHO_N "(cached) $ECHO_C" >&6
11489   else
11490 <  cat >conftest.$ac_ext <<_ACEOF
11491 < #line $LINENO "configure"
11490 >
11491 >      ac_cv_cxx_have_std_iostream=no
11492 >      ac_cv_cxx_need_use_std_iostream=no
11493 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11494 >
11495 >
11496 >        ac_ext=cc
11497 > ac_cpp='$CXXCPP $CPPFLAGS'
11498 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11499 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11500 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11501 >
11502 >        cat >conftest.$ac_ext <<_ACEOF
11503   /* confdefs.h.  */
11504   _ACEOF
11505   cat confdefs.h >>conftest.$ac_ext
11506   cat >>conftest.$ac_ext <<_ACEOF
11507   /* end confdefs.h.  */
11508 < /* System header to define __stub macros and hopefully few prototypes,
11509 <    which can conflict with char $ac_func (); below.
11510 <    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>
11508 >
11509 > #ifdef HAVE_IOSTREAM
11510 > #include <iostream>
11511   #else
11512 < # include <assert.h>
11512 > #include <iostream.h>
11513   #endif
11514 < /* Override any gcc2 internal prototype to avoid an error.  */
11515 < #ifdef __cplusplus
11516 < extern "C"
11517 < {
11514 >
11515 > #ifdef FC_DUMMY_MAIN
11516 > #ifndef FC_DUMMY_MAIN_EQ_F77
11517 > #  ifdef __cplusplus
11518 >     extern "C"
11519 > #  endif
11520 >   int FC_DUMMY_MAIN() { return 1; }
11521   #endif
4907 /* We use char because int might match the return type of a gcc2
4908   builtin and then its argument prototype would still apply.  */
4909 char $ac_func ();
4910 /* The GNU C library defines this for functions which it implements
4911    to always fail with ENOSYS.  Some functions are actually named
4912    something starting with __ and the normal name is an alias.  */
4913 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4914 choke me
4915 #else
4916 char (*f) () = $ac_func;
11522   #endif
4918 #ifdef __cplusplus
4919 }
4920 #endif
4921
11523   int
11524   main ()
11525   {
11526 < return f != $ac_func;
11526 > std::cout<<"Hello World"<<std::endl;return 0;
11527    ;
11528    return 0;
11529   }
11530   _ACEOF
11531 < rm -f conftest.$ac_objext conftest$ac_exeext
11532 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11533 <  (eval $ac_link) 2>&5
11531 > rm -f conftest.$ac_objext
11532 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11533 >  (eval $ac_compile) 2>conftest.er1
11534    ac_status=$?
11535 +  grep -v '^ *+' conftest.er1 >conftest.err
11536 +  rm -f conftest.er1
11537 +  cat conftest.err >&5
11538    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11539    (exit $ac_status); } &&
11540 <         { ac_try='test -s conftest$ac_exeext'
11540 >         { ac_try='test -z "$ac_cxx_werror_flag"
11541 >                         || test ! -s conftest.err'
11542    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11543    (eval $ac_try) 2>&5
11544    ac_status=$?
11545    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11546 +  (exit $ac_status); }; } &&
11547 +         { ac_try='test -s conftest.$ac_objext'
11548 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11549 +  (eval $ac_try) 2>&5
11550 +  ac_status=$?
11551 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11552    (exit $ac_status); }; }; then
11553 <  eval "$as_ac_var=yes"
11553 >  ac_cv_cxx_have_std_iostream=yes
11554   else
11555    echo "$as_me: failed program was:" >&5
11556   sed 's/^/| /' conftest.$ac_ext >&5
11557  
4947 eval "$as_ac_var=no"
11558   fi
11559 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
11560 < fi
11561 < 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
11559 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11560 >        cat >conftest.$ac_ext <<_ACEOF
11561 > /* confdefs.h.  */
11562   _ACEOF
11563 + cat confdefs.h >>conftest.$ac_ext
11564 + cat >>conftest.$ac_ext <<_ACEOF
11565 + /* end confdefs.h.  */
11566  
11567 < fi
11568 < done
11567 > #define __USE_STD_IOSTREAM 1
11568 > #ifdef HAVE_IOSTREAM
11569 > #include <iostream>
11570 > #else
11571 > #include <iostream.h>
11572 > #endif
11573  
11574 < # special check for _system_configuration because AIX <4.3.2 do not
11575 < # contain the `physmem' member.
11576 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
11577 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
11578 < cat >conftest.$ac_ext <<_ACEOF
11579 < #line $LINENO "configure"
11574 > #ifdef FC_DUMMY_MAIN
11575 > #ifndef FC_DUMMY_MAIN_EQ_F77
11576 > #  ifdef __cplusplus
11577 >     extern "C"
11578 > #  endif
11579 >   int FC_DUMMY_MAIN() { return 1; }
11580 > #endif
11581 > #endif
11582 > int
11583 > main ()
11584 > {
11585 > std::cout<<"Hello World"<<std::endl;return 0;
11586 >  ;
11587 >  return 0;
11588 > }
11589 > _ACEOF
11590 > rm -f conftest.$ac_objext
11591 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11592 >  (eval $ac_compile) 2>conftest.er1
11593 >  ac_status=$?
11594 >  grep -v '^ *+' conftest.er1 >conftest.err
11595 >  rm -f conftest.er1
11596 >  cat conftest.err >&5
11597 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11598 >  (exit $ac_status); } &&
11599 >         { ac_try='test -z "$ac_cxx_werror_flag"
11600 >                         || test ! -s conftest.err'
11601 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11602 >  (eval $ac_try) 2>&5
11603 >  ac_status=$?
11604 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11605 >  (exit $ac_status); }; } &&
11606 >         { ac_try='test -s conftest.$ac_objext'
11607 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11608 >  (eval $ac_try) 2>&5
11609 >  ac_status=$?
11610 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11611 >  (exit $ac_status); }; }; then
11612 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11613 > else
11614 >  echo "$as_me: failed program was:" >&5
11615 > sed 's/^/| /' conftest.$ac_ext >&5
11616 >
11617 > fi
11618 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11619 >        ac_ext=cc
11620 > ac_cpp='$CXXCPP $CPPFLAGS'
11621 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11622 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11623 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11624 >
11625 >      fi
11626 >
11627 > fi
11628 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11629 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11630 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11631 >
11632 > cat >>confdefs.h <<\_ACEOF
11633 > #define HAVE_STD_IOSTREAM 1
11634 > _ACEOF
11635 >
11636 >  fi
11637 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11638 >
11639 > cat >>confdefs.h <<\_ACEOF
11640 > #define __USE_STD_IOSTREAM 1
11641 > _ACEOF
11642 >
11643 >  fi
11644 >
11645 >
11646 >
11647 >
11648 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11649 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11650 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11651 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11652 > else
11653 >
11654 >      ac_cv_cxx_have_std_stl=no
11655 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11656 >
11657 >
11658 >        ac_ext=cc
11659 > ac_cpp='$CXXCPP $CPPFLAGS'
11660 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11661 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11662 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11663 >
11664 >        cat >conftest.$ac_ext <<_ACEOF
11665   /* confdefs.h.  */
11666   _ACEOF
11667   cat confdefs.h >>conftest.$ac_ext
11668   cat >>conftest.$ac_ext <<_ACEOF
11669   /* end confdefs.h.  */
11670 < #include <sys/systemcfg.h>
11670 > #include <list>
11671 >
11672 > #ifdef FC_DUMMY_MAIN
11673 > #ifndef FC_DUMMY_MAIN_EQ_F77
11674 > #  ifdef __cplusplus
11675 >     extern "C"
11676 > #  endif
11677 >   int FC_DUMMY_MAIN() { return 1; }
11678 > #endif
11679 > #endif
11680   int
11681   main ()
11682   {
11683 < double x = _system_configuration.physmem;
11683 > std::list<int> foo;return 0;
11684    ;
11685    return 0;
11686   }
11687   _ACEOF
11688   rm -f conftest.$ac_objext
11689   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11690 <  (eval $ac_compile) 2>&5
11690 >  (eval $ac_compile) 2>conftest.er1
11691    ac_status=$?
11692 +  grep -v '^ *+' conftest.er1 >conftest.err
11693 +  rm -f conftest.er1
11694 +  cat conftest.err >&5
11695    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11696    (exit $ac_status); } &&
11697 <         { ac_try='test -s conftest.$ac_objext'
11697 >         { ac_try='test -z "$ac_cxx_werror_flag"
11698 >                         || test ! -s conftest.err'
11699    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11700    (eval $ac_try) 2>&5
11701    ac_status=$?
11702    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11703 +  (exit $ac_status); }; } &&
11704 +         { ac_try='test -s conftest.$ac_objext'
11705 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11706 +  (eval $ac_try) 2>&5
11707 +  ac_status=$?
11708 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11709    (exit $ac_status); }; }; then
11710 <  echo "$as_me:$LINENO: result: yes" >&5
11711 < echo "${ECHO_T}yes" >&6
11710 >  ac_cv_cxx_have_std_stl=yes
11711 > else
11712 >  echo "$as_me: failed program was:" >&5
11713 > sed 's/^/| /' conftest.$ac_ext >&5
11714  
11715 + fi
11716 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11717 +        ac_ext=cc
11718 + ac_cpp='$CXXCPP $CPPFLAGS'
11719 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11720 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11721 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11722 +
11723 +      fi
11724 +
11725 + fi
11726 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11727 + echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11728 +  if test "$ac_cv_cxx_have_std_stl" = yes; then
11729 +
11730   cat >>confdefs.h <<\_ACEOF
11731 < #define HAVE__SYSTEM_CONFIGURATION 1
11731 > #define HAVE_STD_STL 1
11732   _ACEOF
11733  
11734 +  fi
11735 +
11736 +
11737 +
11738 +  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11739 + echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11740 + if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11741 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11742   else
11743 +
11744 +    ac_cv_cxx_have_fstream_attach=no
11745 +
11746 +
11747 +    ac_ext=cc
11748 + ac_cpp='$CXXCPP $CPPFLAGS'
11749 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11750 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11751 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11752 +
11753 +    cat >conftest.$ac_ext <<_ACEOF
11754 + /* confdefs.h.  */
11755 + _ACEOF
11756 + cat confdefs.h >>conftest.$ac_ext
11757 + cat >>conftest.$ac_ext <<_ACEOF
11758 + /* end confdefs.h.  */
11759 +
11760 + #ifdef HAVE_IOSTREAM
11761 + #include <fstream>
11762 + #else
11763 + #include <fstream.h>
11764 + #endif
11765 + #ifdef HAVE_STD_IOSTREAM
11766 + using namespace std;
11767 + #endif
11768 +
11769 + #ifdef FC_DUMMY_MAIN
11770 + #ifndef FC_DUMMY_MAIN_EQ_F77
11771 + #  ifdef __cplusplus
11772 +     extern "C"
11773 + #  endif
11774 +   int FC_DUMMY_MAIN() { return 1; }
11775 + #endif
11776 + #endif
11777 + int
11778 + main ()
11779 + {
11780 + int fd=0;ofstream s;s.attach(fd);
11781 +  ;
11782 +  return 0;
11783 + }
11784 + _ACEOF
11785 + rm -f conftest.$ac_objext
11786 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11787 +  (eval $ac_compile) 2>conftest.er1
11788 +  ac_status=$?
11789 +  grep -v '^ *+' conftest.er1 >conftest.err
11790 +  rm -f conftest.er1
11791 +  cat conftest.err >&5
11792 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11793 +  (exit $ac_status); } &&
11794 +         { ac_try='test -z "$ac_cxx_werror_flag"
11795 +                         || test ! -s conftest.err'
11796 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11797 +  (eval $ac_try) 2>&5
11798 +  ac_status=$?
11799 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11800 +  (exit $ac_status); }; } &&
11801 +         { ac_try='test -s conftest.$ac_objext'
11802 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11803 +  (eval $ac_try) 2>&5
11804 +  ac_status=$?
11805 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11806 +  (exit $ac_status); }; }; then
11807 +  ac_cv_cxx_have_fstream_attach=yes
11808 + else
11809    echo "$as_me: failed program was:" >&5
11810   sed 's/^/| /' conftest.$ac_ext >&5
11811  
5004 echo "$as_me:$LINENO: result: no" >&5
5005 echo "${ECHO_T}no" >&6
11812   fi
11813 < rm -f conftest.$ac_objext conftest.$ac_ext
11813 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11814 >    ac_ext=cc
11815 > ac_cpp='$CXXCPP $CPPFLAGS'
11816 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11817 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11818 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11819  
5009  # clean out junk possibly left behind by a previous configuration
5010  rm -f src/getopt.h
5011  # Check for getopt_long support
11820  
11821 < for ac_header in getopt.h
11821 > fi
11822 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11823 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11824 >  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11825 >
11826 > cat >>confdefs.h <<\_ACEOF
11827 > #define HAVE_FSTREAM_ATTACH 1
11828 > _ACEOF
11829 >
11830 >  fi
11831 >
11832 >
11833 >
11834 >  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11835 > echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11836 > if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11837 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11838 > else
11839 >
11840 >    ac_cv_cxx_have_fstream_open=no
11841 >    ac_cv_cxx_fstream_open_prot=no
11842 >
11843 >
11844 >    ac_ext=cc
11845 > ac_cpp='$CXXCPP $CPPFLAGS'
11846 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11847 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11848 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11849 >
11850 >    # Try with 2 parameters
11851 >    cat >conftest.$ac_ext <<_ACEOF
11852 > /* confdefs.h.  */
11853 > _ACEOF
11854 > cat confdefs.h >>conftest.$ac_ext
11855 > cat >>conftest.$ac_ext <<_ACEOF
11856 > /* end confdefs.h.  */
11857 >
11858 > #ifdef HAVE_IOSTREAM
11859 > #include <fstream>
11860 > #else
11861 > #include <fstream.h>
11862 > #endif
11863 > #ifdef HAVE_STD_IOSTREAM
11864 > using namespace std;
11865 > #endif
11866 >
11867 > #ifdef FC_DUMMY_MAIN
11868 > #ifndef FC_DUMMY_MAIN_EQ_F77
11869 > #  ifdef __cplusplus
11870 >     extern "C"
11871 > #  endif
11872 >   int FC_DUMMY_MAIN() { return 1; }
11873 > #endif
11874 > #endif
11875 > int
11876 > main ()
11877 > {
11878 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11879 >  ;
11880 >  return 0;
11881 > }
11882 > _ACEOF
11883 > rm -f conftest.$ac_objext
11884 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11885 >  (eval $ac_compile) 2>conftest.er1
11886 >  ac_status=$?
11887 >  grep -v '^ *+' conftest.er1 >conftest.err
11888 >  rm -f conftest.er1
11889 >  cat conftest.err >&5
11890 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11891 >  (exit $ac_status); } &&
11892 >         { ac_try='test -z "$ac_cxx_werror_flag"
11893 >                         || test ! -s conftest.err'
11894 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11895 >  (eval $ac_try) 2>&5
11896 >  ac_status=$?
11897 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11898 >  (exit $ac_status); }; } &&
11899 >         { ac_try='test -s conftest.$ac_objext'
11900 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11901 >  (eval $ac_try) 2>&5
11902 >  ac_status=$?
11903 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11904 >  (exit $ac_status); }; }; then
11905 >  ac_cv_cxx_have_fstream_open=yes
11906 > else
11907 >  echo "$as_me: failed program was:" >&5
11908 > sed 's/^/| /' conftest.$ac_ext >&5
11909 >
11910 > fi
11911 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11912 >    # Try with mode parameter
11913 >    cat >conftest.$ac_ext <<_ACEOF
11914 > /* confdefs.h.  */
11915 > _ACEOF
11916 > cat confdefs.h >>conftest.$ac_ext
11917 > cat >>conftest.$ac_ext <<_ACEOF
11918 > /* end confdefs.h.  */
11919 >
11920 > #ifdef HAVE_IOSTREAM
11921 > #include <fstream>
11922 > #else
11923 > #include <fstream.h>
11924 > #endif
11925 > #ifdef HAVE_STD_IOSTREAM
11926 > using namespace std;
11927 > #endif
11928 >
11929 > #ifdef FC_DUMMY_MAIN
11930 > #ifndef FC_DUMMY_MAIN_EQ_F77
11931 > #  ifdef __cplusplus
11932 >     extern "C"
11933 > #  endif
11934 >   int FC_DUMMY_MAIN() { return 1; }
11935 > #endif
11936 > #endif
11937 > int
11938 > main ()
11939 > {
11940 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11941 >  ;
11942 >  return 0;
11943 > }
11944 > _ACEOF
11945 > rm -f conftest.$ac_objext
11946 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11947 >  (eval $ac_compile) 2>conftest.er1
11948 >  ac_status=$?
11949 >  grep -v '^ *+' conftest.er1 >conftest.err
11950 >  rm -f conftest.er1
11951 >  cat conftest.err >&5
11952 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11953 >  (exit $ac_status); } &&
11954 >         { ac_try='test -z "$ac_cxx_werror_flag"
11955 >                         || test ! -s conftest.err'
11956 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11957 >  (eval $ac_try) 2>&5
11958 >  ac_status=$?
11959 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11960 >  (exit $ac_status); }; } &&
11961 >         { ac_try='test -s conftest.$ac_objext'
11962 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11963 >  (eval $ac_try) 2>&5
11964 >  ac_status=$?
11965 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11966 >  (exit $ac_status); }; }; then
11967 >  ac_cv_cxx_fstream_open_prot=yes
11968 > else
11969 >  echo "$as_me: failed program was:" >&5
11970 > sed 's/^/| /' conftest.$ac_ext >&5
11971 >
11972 > fi
11973 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11974 >    ac_ext=cc
11975 > ac_cpp='$CXXCPP $CPPFLAGS'
11976 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11977 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11978 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11979 >
11980 >
11981 > fi
11982 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11983 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11984 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11985 >
11986 > cat >>confdefs.h <<\_ACEOF
11987 > #define HAVE_FSTREAM_OPEN 1
11988 > _ACEOF
11989 >
11990 >  fi
11991 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11992 >
11993 > cat >>confdefs.h <<\_ACEOF
11994 > #define FSTREAM_OPEN_PROT 1
11995 > _ACEOF
11996 >
11997 >  fi
11998 >
11999 >
12000 >
12001 >
12002 >
12003 >
12004 >
12005 > for ac_header in ctype.h iostream fstream sstream strstream
12006   do
12007   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
12008   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 5026 | Line 12018 | cat >conftest.$ac_ext <<_ACEOF
12018   echo "$as_me:$LINENO: checking $ac_header usability" >&5
12019   echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
12020   cat >conftest.$ac_ext <<_ACEOF
5029 #line $LINENO "configure"
12021   /* confdefs.h.  */
12022   _ACEOF
12023   cat confdefs.h >>conftest.$ac_ext
# Line 5037 | Line 12028 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12028   _ACEOF
12029   rm -f conftest.$ac_objext
12030   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12031 <  (eval $ac_compile) 2>&5
12031 >  (eval $ac_compile) 2>conftest.er1
12032    ac_status=$?
12033 +  grep -v '^ *+' conftest.er1 >conftest.err
12034 +  rm -f conftest.er1
12035 +  cat conftest.err >&5
12036    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12037    (exit $ac_status); } &&
12038 <         { ac_try='test -s conftest.$ac_objext'
12038 >         { ac_try='test -z "$ac_cxx_werror_flag"
12039 >                         || test ! -s conftest.err'
12040    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12041    (eval $ac_try) 2>&5
12042    ac_status=$?
12043    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12044 +  (exit $ac_status); }; } &&
12045 +         { ac_try='test -s conftest.$ac_objext'
12046 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12047 +  (eval $ac_try) 2>&5
12048 +  ac_status=$?
12049 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12050    (exit $ac_status); }; }; then
12051    ac_header_compiler=yes
12052   else
# Line 5054 | Line 12055 | fi
12055  
12056   ac_header_compiler=no
12057   fi
12058 < rm -f conftest.$ac_objext conftest.$ac_ext
12058 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12059   echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
12060   echo "${ECHO_T}$ac_header_compiler" >&6
12061  
# Line 5062 | Line 12063 | cat >conftest.$ac_ext <<_ACEOF
12063   echo "$as_me:$LINENO: checking $ac_header presence" >&5
12064   echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
12065   cat >conftest.$ac_ext <<_ACEOF
5065 #line $LINENO "configure"
12066   /* confdefs.h.  */
12067   _ACEOF
12068   cat confdefs.h >>conftest.$ac_ext
# Line 5079 | Line 12079 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
12079    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12080    (exit $ac_status); } >/dev/null; then
12081    if test -s conftest.err; then
12082 <    ac_cpp_err=$ac_c_preproc_warn_flag
12082 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
12083 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
12084    else
12085      ac_cpp_err=
12086    fi
# Line 5099 | Line 12100 | echo "${ECHO_T}$ac_header_preproc" >&6
12100   echo "${ECHO_T}$ac_header_preproc" >&6
12101  
12102   # So?  What about this header?
12103 < case $ac_header_compiler:$ac_header_preproc in
12104 <  yes:no )
12103 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
12104 >  yes:no: )
12105      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
12106   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
12107 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
12108 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
12109 <    (
5109 <      cat <<\_ASBOX
5110 < ## ------------------------------------ ##
5111 < ## Report this to bug-autoconf@gnu.org. ##
5112 < ## ------------------------------------ ##
5113 < _ASBOX
5114 <    ) |
5115 <      sed "s/^/$as_me: WARNING:     /" >&2
12107 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
12108 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
12109 >    ac_header_preproc=yes
12110      ;;
12111 <  no:yes )
12111 >  no:yes:* )
12112      { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
12113   echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
12114 <    { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5
12115 < echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}
12114 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
12115 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
12116 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
12117 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
12118 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
12119 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
12120      { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
12121   echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
12122 +    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
12123 + echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
12124      (
12125        cat <<\_ASBOX
12126 < ## ------------------------------------ ##
12127 < ## Report this to bug-autoconf@gnu.org. ##
12128 < ## ------------------------------------ ##
12126 > ## ------------------------------ ##
12127 > ## Report this to gezelter@nd.edu ##
12128 > ## ------------------------------ ##
12129   _ASBOX
12130      ) |
12131        sed "s/^/$as_me: WARNING:     /" >&2
# Line 5136 | Line 12136 | else
12136   if eval "test \"\${$as_ac_Header+set}\" = set"; then
12137    echo $ECHO_N "(cached) $ECHO_C" >&6
12138   else
12139 <  eval "$as_ac_Header=$ac_header_preproc"
12139 >  eval "$as_ac_Header=\$ac_header_preproc"
12140   fi
12141   echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
12142   echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
# Line 5151 | Line 12151 | done
12151  
12152   done
12153  
12154 + # AC_CPP_FUNC
12155 + # ------------------ #
12156 + # Checks to see if ANSI C99 CPP variable __func__ works.
12157 + # If not, perhaps __FUNCTION__ works instead.
12158 + # If not, we'll just define __func__ to "".
12159 + # AC_CPP_FUNC
12160  
12161 < for ac_func in getopt_long
12162 < do
12163 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
12164 < 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
12161 >
12162 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
12163 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
12164 > if test "${ac_cv_cpp_func+set}" = set; then
12165    echo $ECHO_N "(cached) $ECHO_C" >&6
12166   else
12167    cat >conftest.$ac_ext <<_ACEOF
5164 #line $LINENO "configure"
12168   /* confdefs.h.  */
12169   _ACEOF
12170   cat confdefs.h >>conftest.$ac_ext
12171   cat >>conftest.$ac_ext <<_ACEOF
12172   /* end confdefs.h.  */
12173 < /* System header to define __stub macros and hopefully few prototypes,
12174 <    which can conflict with char $ac_func (); below.
12175 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
12176 <    <limits.h> exists even on freestanding compilers.  */
12177 < #ifdef __STDC__
12178 < # include <limits.h>
12179 < #else
5177 < # include <assert.h>
12173 >
12174 > #ifdef FC_DUMMY_MAIN
12175 > #ifndef FC_DUMMY_MAIN_EQ_F77
12176 > #  ifdef __cplusplus
12177 >     extern "C"
12178 > #  endif
12179 >   int FC_DUMMY_MAIN() { return 1; }
12180   #endif
5179 /* Override any gcc2 internal prototype to avoid an error.  */
5180 #ifdef __cplusplus
5181 extern "C"
5182 {
12181   #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
12182   int
12183   main ()
12184   {
12185 < return f != $ac_func;
12185 > const char *foo = __func__;
12186    ;
12187    return 0;
12188   }
12189   _ACEOF
12190 < rm -f conftest.$ac_objext conftest$ac_exeext
12191 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12192 <  (eval $ac_link) 2>&5
12190 > rm -f conftest.$ac_objext
12191 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12192 >  (eval $ac_compile) 2>conftest.er1
12193    ac_status=$?
12194 +  grep -v '^ *+' conftest.er1 >conftest.err
12195 +  rm -f conftest.er1
12196 +  cat conftest.err >&5
12197    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12198    (exit $ac_status); } &&
12199 <         { ac_try='test -s conftest$ac_exeext'
12199 >         { ac_try='test -z "$ac_cxx_werror_flag"
12200 >                         || test ! -s conftest.err'
12201    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12202    (eval $ac_try) 2>&5
12203    ac_status=$?
12204    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12205 +  (exit $ac_status); }; } &&
12206 +         { ac_try='test -s conftest.$ac_objext'
12207 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12208 +  (eval $ac_try) 2>&5
12209 +  ac_status=$?
12210 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12211    (exit $ac_status); }; }; then
12212 <  eval "$as_ac_var=yes"
12212 >  ac_cv_cpp_func=yes
12213   else
12214    echo "$as_me: failed program was:" >&5
12215   sed 's/^/| /' conftest.$ac_ext >&5
12216  
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"
12217   cat >conftest.$ac_ext <<_ACEOF
5245 #line $LINENO "configure"
12218   /* confdefs.h.  */
12219   _ACEOF
12220   cat confdefs.h >>conftest.$ac_ext
12221   cat >>conftest.$ac_ext <<_ACEOF
12222   /* end confdefs.h.  */
12223  
12224 < /* Override any gcc2 internal prototype to avoid an error.  */
12225 < #ifdef __cplusplus
12226 < extern "C"
12224 > #ifdef FC_DUMMY_MAIN
12225 > #ifndef FC_DUMMY_MAIN_EQ_F77
12226 > #  ifdef __cplusplus
12227 >     extern "C"
12228 > #  endif
12229 >   int FC_DUMMY_MAIN() { return 1; }
12230   #endif
12231 < /* 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 ();
12231 > #endif
12232   int
12233   main ()
12234   {
12235 < getopt_long ();
12235 > const char *foo = __FUNCTION__;
12236    ;
12237    return 0;
12238   }
12239   _ACEOF
12240 < rm -f conftest.$ac_objext conftest$ac_exeext
12241 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
12242 <  (eval $ac_link) 2>&5
12240 > rm -f conftest.$ac_objext
12241 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12242 >  (eval $ac_compile) 2>conftest.er1
12243    ac_status=$?
12244 +  grep -v '^ *+' conftest.er1 >conftest.err
12245 +  rm -f conftest.er1
12246 +  cat conftest.err >&5
12247    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12248    (exit $ac_status); } &&
12249 <         { ac_try='test -s conftest$ac_exeext'
12249 >         { ac_try='test -z "$ac_cxx_werror_flag"
12250 >                         || test ! -s conftest.err'
12251    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12252    (eval $ac_try) 2>&5
12253    ac_status=$?
12254    echo "$as_me:$LINENO: \$? = $ac_status" >&5
12255 +  (exit $ac_status); }; } &&
12256 +         { ac_try='test -s conftest.$ac_objext'
12257 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12258 +  (eval $ac_try) 2>&5
12259 +  ac_status=$?
12260 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12261    (exit $ac_status); }; }; then
12262 <  ac_cv_lib_gnugetopt_getopt_long=yes
12262 >  ac_cv_cpp_func=__FUNCTION__
12263   else
12264    echo "$as_me: failed program was:" >&5
12265   sed 's/^/| /' conftest.$ac_ext >&5
12266  
12267 < ac_cv_lib_gnugetopt_getopt_long=no
12267 > ac_cv_cpp_func=no
12268   fi
12269 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
5287 < LIBS=$ac_check_lib_save_LIBS
12269 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12270   fi
12271 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
12272 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
12273 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
12274 <  cat >>confdefs.h <<\_ACEOF
12275 < #define HAVE_GETOPT_LONG 1
12271 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12272 > fi
12273 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
12274 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
12275 > if test $ac_cv_cpp_func = __FUNCTION__; then
12276 >
12277 > cat >>confdefs.h <<\_ACEOF
12278 > #define __func__ __FUNCTION__
12279   _ACEOF
12280  
12281 < 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"
12281 > elif test $ac_cv_cpp_func = no; then
12282  
12283 < fi
12283 > cat >>confdefs.h <<\_ACEOF
12284 > #define __func__ ""
12285 > _ACEOF
12286  
12287   fi
5305 done
12288  
12289  
12290  
12291 +
12292 +
12293   case $debug in
12294    1)
12295       ;;
12296    *)
12297 +
12298 +
12299 +
12300 +
12301 + # Try to determine "good" native compiler flags if none specified on command
12302 + # line
12303 +
12304 + if test "$ac_test_FFLAGS" != "set"; then
12305 +  FCFLAGS=""
12306 +  case "${host_cpu}-${host_os}" in
12307 +
12308 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
12309 +                    FCFLAGS="-O3 -ip -no-prec-div"
12310 +                fi;;
12311 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
12312 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12313 +                fi;;
12314 +   powerpc*-aix*)
12315 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12316 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
12317 +                echo "*******************************************************"
12318 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12319 +                echo "*  recommended that you use                           *"
12320 +                echo "*                                                     *"
12321 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12322 +                echo "*                                 ^^^                 *"
12323 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12324 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12325 +                echo "*******************************************************"
12326 +        fi;;
12327 +   *darwin*)
12328 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12329 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12330 +        fi
12331 +        if test "$FC" = ifort; then
12332 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
12333 +        fi;;
12334 +  esac
12335 +
12336 +  if test -n "$CPU_FLAGS"; then
12337 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
12338 +  fi
12339 +
12340 +  if test -z "$FCFLAGS"; then
12341 +        echo ""
12342 +        echo "*********************************************************"
12343 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12344 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12345 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
12346 +        echo "*********************************************************"
12347 +        echo ""
12348 +        FCFLAGS="-O3"
12349 +  fi
12350 +
12351 +
12352 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12353 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
12354 + if test "${ac_guessed_f90flags+set}" = set; then
12355 +  echo $ECHO_N "(cached) $ECHO_C" >&6
12356 + else
12357 +
12358 +
12359 +
12360 + ac_ext=${FC_SRCEXT-f}
12361 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
12362 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
12363 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12364 +
12365 + echo 'program main' > conftest.$ac_ext
12366 + echo 'end program main' >> conftest.$ac_ext
12367 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12368 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12369 +  (eval $ac_compile) 2>&5
12370 +  ac_status=$?
12371 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12372 +  (exit $ac_status); }; then
12373 +        ac_guessed_f90flags=yes
12374 + else
12375 +        ac_guessed_f90flags=no
12376 + fi
12377 + rm -f conftest*
12378 + ac_ext=cc
12379 + ac_cpp='$CXXCPP $CPPFLAGS'
12380 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12381 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12382 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12383 +
12384 +
12385 + fi
12386 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12387 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
12388 + if test "$ac_guessed_f90flags" = yes; then
12389 +        :
12390 +
12391 + else
12392 +        :
12393 +
12394 +        echo ""
12395 +        echo "**********************************************************"
12396 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12397 +        echo "* your compiler.                                        *"
12398 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12399 +        echo "*********************************************************"
12400 +        echo ""
12401 +        FCFLAGS=""
12402 +
12403 + fi
12404 +
12405 +
12406 + fi
12407  
12408  
12409  
12410  
12411  
12412  
12413 +
12414   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12415   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12416   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 5324 | Line 12419 | cat > conftest.c <<EOF
12419  
12420   cat > conftest.c <<EOF
12421   #ifdef __GNUC__
12422 <  #ifndef __INTEL_COMPILER
12422 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12423 >     no;
12424 >  #else
12425       yes;
12426    #endif
12427   #endif
# Line 5362 | Line 12459 | if test "$ac_test_CFLAGS" != "set"; then
12459                      CFLAGS="-O"
12460                  fi;;
12461    sparc-solaris2*) if test "$CC" = cc; then
12462 <                    CFLAGS="-native -fast -xO5 -dalign"
12462 >                    CFLAGS="-O -dalign"
12463                   fi;;
12464  
12465    alpha*-osf*)  if test "$CC" = cc; then
# Line 5392 | Line 12489 | if test "$ac_test_CFLAGS" != "set"; then
12489     *darwin*)
12490          if test "$CC" = xlc -o "$CC" = cc; then
12491                  CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12492 +        fi
12493 +        if test "$CC" = icc; then
12494 +                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12495          fi;;
12496    esac
12497  
12498    # use default flags for gcc on all systems
12499    if test $ac_cv_prog_really_gcc = yes; then
12500 <     CFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
12500 >     CFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align"
12501    fi
12502  
12503    # test for gcc-specific flags:
# Line 5405 | Line 12505 | if test "$ac_test_CFLAGS" != "set"; then
12505      # -malign-double for x86 systems
12506  
12507  
12508 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12509 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12508 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12509 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12510   if test "${ac_align_double+set}" = set; then
12511    echo $ECHO_N "(cached) $ECHO_C" >&6
12512   else
12513    echo 'void f(){}' > conftest.c
12514 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12514 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12515          ac_align_double=yes
12516   else
12517          ac_align_double=no
# Line 5432 | Line 12532 | fi
12532      # -fstrict-aliasing for gcc-2.95+
12533  
12534  
12535 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12536 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12535 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12536 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12537   if test "${ac_fstrict_aliasing+set}" = set; then
12538    echo $ECHO_N "(cached) $ECHO_C" >&6
12539   else
12540    echo 'void f(){}' > conftest.c
12541 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12541 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12542          ac_fstrict_aliasing=yes
12543   else
12544          ac_fstrict_aliasing=no
# Line 5463 | Line 12563 | fi
12563                    case "${host_cpu}" in
12564            i586*)
12565  
12566 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12567 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12566 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12567 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12568   if test "${ac_cpu_pentium+set}" = set; then
12569    echo $ECHO_N "(cached) $ECHO_C" >&6
12570   else
12571    echo 'void f(){}' > conftest.c
12572 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12572 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12573          ac_cpu_pentium=yes
12574   else
12575          ac_cpu_pentium=no
# Line 5486 | Line 12586 | else
12586          :
12587  
12588  
12589 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12590 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12589 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12590 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12591   if test "${ac_pentium+set}" = set; then
12592    echo $ECHO_N "(cached) $ECHO_C" >&6
12593   else
12594    echo 'void f(){}' > conftest.c
12595 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12595 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12596          ac_pentium=yes
12597   else
12598          ac_pentium=no
# Line 5515 | Line 12615 | fi
12615                    ;;
12616            i686*)
12617  
12618 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12619 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12618 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12619 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12620   if test "${ac_cpu_pentiumpro+set}" = set; then
12621    echo $ECHO_N "(cached) $ECHO_C" >&6
12622   else
12623    echo 'void f(){}' > conftest.c
12624 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12624 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12625          ac_cpu_pentiumpro=yes
12626   else
12627          ac_cpu_pentiumpro=no
# Line 5538 | Line 12638 | else
12638          :
12639  
12640  
12641 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12642 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12641 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12642 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12643   if test "${ac_pentiumpro+set}" = set; then
12644    echo $ECHO_N "(cached) $ECHO_C" >&6
12645   else
12646    echo 'void f(){}' > conftest.c
12647 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12647 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12648          ac_pentiumpro=yes
12649   else
12650          ac_pentiumpro=no
# Line 5571 | Line 12671 | fi
12671                  if test -n "$is60x"; then
12672  
12673  
12674 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12675 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12674 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12675 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12676   if test "${ac_m_cpu_60x+set}" = set; then
12677    echo $ECHO_N "(cached) $ECHO_C" >&6
12678   else
12679    echo 'void f(){}' > conftest.c
12680 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12680 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12681          ac_m_cpu_60x=yes
12682   else
12683          ac_m_cpu_60x=no
# Line 5629 | Line 12729 | if test "$ac_cv_prog_gcc_2_95" = yes; then
12729          :
12730  
12731  
12732 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12733 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12732 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12733 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12734   if test "${ac_m_cpu_750+set}" = set; then
12735    echo $ECHO_N "(cached) $ECHO_C" >&6
12736   else
12737    echo 'void f(){}' > conftest.c
12738 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12738 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12739          ac_m_cpu_750=yes
12740   else
12741          ac_m_cpu_750=no
# Line 5662 | Line 12762 | fi
12762                  if test -z "$CPU_FLAGS"; then
12763  
12764  
12765 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12766 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12765 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12766 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12767   if test "${ac_m_cpu_powerpc+set}" = set; then
12768    echo $ECHO_N "(cached) $ECHO_C" >&6
12769   else
12770    echo 'void f(){}' > conftest.c
12771 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12771 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12772          ac_m_cpu_powerpc=yes
12773   else
12774          ac_m_cpu_powerpc=no
# Line 5690 | Line 12790 | fi
12790                  if test -z "$CPU_FLAGS"; then
12791  
12792  
12793 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12794 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12793 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12794 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12795   if test "${ac_m_powerpc+set}" = set; then
12796    echo $ECHO_N "(cached) $ECHO_C" >&6
12797   else
12798    echo 'void f(){}' > conftest.c
12799 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12799 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12800          ac_m_powerpc=yes
12801   else
12802          ac_m_powerpc=no
# Line 5735 | Line 12835 | fi
12835  
12836  
12837  
12838 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12839 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12838 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12839 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12840   if test "${ac_guessed_cflags+set}" = set; then
12841    echo $ECHO_N "(cached) $ECHO_C" >&6
12842   else
12843    echo 'void f(){}' > conftest.c
12844 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12844 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12845          ac_guessed_cflags=yes
12846   else
12847          ac_guessed_cflags=no
# Line 5785 | Line 12885 | cat > conftest.cpp <<EOF
12885  
12886   cat > conftest.cpp <<EOF
12887   #ifdef __GNUC__
12888 <  #ifndef __INTEL_COMPILER
12888 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12889 >     no;
12890 >  #else
12891       yes;
12892    #endif
12893   #endif
# Line 5823 | Line 12925 | if test "$ac_test_CXXFLAGS" != "set"; then
12925                      CXXFLAGS="-O"
12926                  fi;;
12927    sparc-solaris2*) if test "$CXX" = CC; then
12928 <                    CXXFLAGS="-native -fast -xO5 -dalign"
12928 >                    CXXFLAGS="-features=extensions -O -dalign"
12929                   fi;;
12930     rs6000*-aix*)  if test "$CXX" = xlC; then
12931                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 5844 | Line 12946 | if test "$ac_test_CXXFLAGS" != "set"; then
12946     *darwin*)
12947          if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12948                  CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12949 +        fi
12950 +        if test "$CXX" = icpc; then
12951 +                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12952          fi;;
12953    esac
12954  
12955    # use default flags for gcc on all systems
12956    if test $ac_cv_prog_really_gxx = yes; then
12957 <     CXXFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align -pedantic"
12957 >     CXXFLAGS="-O6 -fomit-frame-pointer -Wall -W -Wcast-qual -Wpointer-arith -Wcast-align"
12958    fi
12959  
12960    # test for gcc-specific flags:
# Line 5857 | Line 12962 | if test "$ac_test_CXXFLAGS" != "set"; then
12962      # -malign-double for x86 systems
12963  
12964  
12965 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12966 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12965 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12966 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12967   if test "${ac_align_double+set}" = set; then
12968    echo $ECHO_N "(cached) $ECHO_C" >&6
12969   else
12970    echo 'void f(){}' > conftest.cpp
12971 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12971 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12972          ac_align_double=yes
12973   else
12974          ac_align_double=no
# Line 5884 | Line 12989 | fi
12989      # -fstrict-aliasing for gcc-2.95+
12990  
12991  
12992 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12993 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12992 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12993 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12994   if test "${ac_fstrict_aliasing+set}" = set; then
12995    echo $ECHO_N "(cached) $ECHO_C" >&6
12996   else
12997    echo 'void f(){}' > conftest.cpp
12998 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12998 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12999          ac_fstrict_aliasing=yes
13000   else
13001          ac_fstrict_aliasing=no
# Line 5915 | Line 13020 | fi
13020                    case "${host_cpu}" in
13021            i586*)
13022  
13023 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
13024 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
13023 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
13024 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
13025   if test "${ac_cpu_pentium+set}" = set; then
13026    echo $ECHO_N "(cached) $ECHO_C" >&6
13027   else
13028    echo 'void f(){}' > conftest.cpp
13029 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
13029 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
13030          ac_cpu_pentium=yes
13031   else
13032          ac_cpu_pentium=no
# Line 5938 | Line 13043 | else
13043          :
13044  
13045  
13046 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
13047 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
13046 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
13047 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
13048   if test "${ac_pentium+set}" = set; then
13049    echo $ECHO_N "(cached) $ECHO_C" >&6
13050   else
13051    echo 'void f(){}' > conftest.cpp
13052 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
13052 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
13053          ac_pentium=yes
13054   else
13055          ac_pentium=no
# Line 5967 | Line 13072 | fi
13072                    ;;
13073            i686*)
13074  
13075 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
13076 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13075 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
13076 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
13077   if test "${ac_cpu_pentiumpro+set}" = set; then
13078    echo $ECHO_N "(cached) $ECHO_C" >&6
13079   else
13080    echo 'void f(){}' > conftest.cpp
13081 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13081 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
13082          ac_cpu_pentiumpro=yes
13083   else
13084          ac_cpu_pentiumpro=no
# Line 5990 | Line 13095 | else
13095          :
13096  
13097  
13098 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
13099 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
13098 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
13099 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
13100   if test "${ac_pentiumpro+set}" = set; then
13101    echo $ECHO_N "(cached) $ECHO_C" >&6
13102   else
13103    echo 'void f(){}' > conftest.cpp
13104 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
13104 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
13105          ac_pentiumpro=yes
13106   else
13107          ac_pentiumpro=no
# Line 6023 | Line 13128 | fi
13128                  if test -n "$is60x"; then
13129  
13130  
13131 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
13132 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
13131 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
13132 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
13133   if test "${ac_m_cpu_60x+set}" = set; then
13134    echo $ECHO_N "(cached) $ECHO_C" >&6
13135   else
13136    echo 'void f(){}' > conftest.cpp
13137 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13137 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
13138          ac_m_cpu_60x=yes
13139   else
13140          ac_m_cpu_60x=no
# Line 6081 | Line 13186 | if test "$ac_cv_prog_gxx_2_95" = yes; then
13186          :
13187  
13188  
13189 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
13190 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
13189 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
13190 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
13191   if test "${ac_m_cpu_750+set}" = set; then
13192    echo $ECHO_N "(cached) $ECHO_C" >&6
13193   else
13194    echo 'void f(){}' > conftest.cpp
13195 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
13195 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
13196          ac_m_cpu_750=yes
13197   else
13198          ac_m_cpu_750=no
13199   fi
13200   rm -f conftest*
13201  
13202 < fi
13203 < echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
13204 < echo "${ECHO_T}$ac_m_cpu_750" >&6
13205 < if test "$ac_m_cpu_750" = yes; then
13206 <        :
13207 <        CPU_FLAGS=-mcpu=750
6103 < else
6104 <        :
6105 <
6106 < fi
6107 <
6108 < else
6109 <        :
6110 <
6111 < fi
6112 <
6113 <                fi
6114 <                if test -z "$CPU_FLAGS"; then
6115 <
6116 <
6117 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
6118 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
6119 < if test "${ac_m_cpu_powerpc+set}" = set; then
6120 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6121 < else
6122 <  echo 'void f(){}' > conftest.cpp
6123 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
6124 <        ac_m_cpu_powerpc=yes
6125 < else
6126 <        ac_m_cpu_powerpc=no
6127 < fi
6128 < rm -f conftest*
6129 <
6130 < fi
6131 < echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
6132 < echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
6133 < if test "$ac_m_cpu_powerpc" = yes; then
6134 <        :
6135 <        CPU_FLAGS=-mcpu=powerpc
6136 < else
6137 <        :
6138 <
6139 < fi
6140 <
6141 <                fi
6142 <                if test -z "$CPU_FLAGS"; then
6143 <
6144 <
6145 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
6146 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
6147 < if test "${ac_m_powerpc+set}" = set; then
6148 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6149 < else
6150 <  echo 'void f(){}' > conftest.cpp
6151 < if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
6152 <        ac_m_powerpc=yes
6153 < else
6154 <        ac_m_powerpc=no
6155 < fi
6156 < rm -f conftest*
6157 <
6158 < fi
6159 < echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
6160 < echo "${ECHO_T}$ac_m_powerpc" >&6
6161 < if test "$ac_m_powerpc" = yes; then
6162 <        :
6163 <        CPU_FLAGS=-mpowerpc
6164 < else
6165 <        :
6166 <
6167 < fi
6168 <
6169 <                fi
6170 <          esac
6171 <  fi
6172 <
6173 <  if test -n "$CPU_FLAGS"; then
6174 <        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
6175 <  fi
6176 <
6177 <  if test -z "$CXXFLAGS"; then
6178 <        echo ""
6179 <        echo "**********************************************************"
6180 <        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
6181 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6182 <        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
6183 <        echo "**********************************************************"
6184 <        echo ""
6185 <        CXXFLAGS="-O3"
6186 <  fi
6187 <
6188 <
6189 <
6190 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
6191 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
6192 < if test "${ac_guessed_cxxflags+set}" = set; then
6193 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6194 < else
6195 <  echo 'void f(){}' > conftest.cpp
6196 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
6197 <        ac_guessed_cxxflags=yes
6198 < else
6199 <        ac_guessed_cxxflags=no
6200 < fi
6201 < rm -f conftest*
6202 <
6203 < fi
6204 < echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
6205 < echo "${ECHO_T}$ac_guessed_cxxflags" >&6
6206 < if test "$ac_guessed_cxxflags" = yes; then
6207 <        :
6208 <
6209 < else
6210 <        :
6211 <
6212 <        echo ""
6213 <        echo "**********************************************************"
6214 <        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
6215 <        echo "* your compiler.                                         *"
6216 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6217 <        echo "**********************************************************"
6218 <        echo ""
6219 <        CXXFLAGS=""
6220 <
6221 < fi
6222 <
6223 <
6224 < fi
6225 <
6226 <
6227 <
6228 <
6229 <
6230 < # Try to determine "good" native compiler flags if none specified on command
6231 < # line
6232 <
6233 < if test x"$F90FLAGS" = x ; then
6234 <  F90FLAGS=""
6235 <  case "${host_cpu}-${host_os}" in
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 <
6334 <     ;;
6335 < esac
6336 <
6337 < # Find a good install program.  We prefer a C program (faster),
6338 < # so one script is as good as another.  But avoid the broken or
6339 < # incompatible versions:
6340 < # SysV /etc/install, /usr/sbin/install
6341 < # SunOS /usr/etc/install
6342 < # IRIX /sbin/install
6343 < # AIX /bin/install
6344 < # AmigaOS /C/install, which installs bootblocks on floppy discs
6345 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
6346 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
6347 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
6348 < # ./install, which can be erroneously created by make from ./install.sh.
6349 < echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
6350 < echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
6351 < if test -z "$INSTALL"; then
6352 < if test "${ac_cv_path_install+set}" = set; then
6353 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6354 < else
6355 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6356 < for as_dir in $PATH
6357 < do
6358 <  IFS=$as_save_IFS
6359 <  test -z "$as_dir" && as_dir=.
6360 <  # Account for people who put trailing slashes in PATH elements.
6361 < case $as_dir/ in
6362 <  ./ | .// | /cC/* | \
6363 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
6364 <  /usr/ucb/* ) ;;
6365 <  *)
6366 <    # OSF1 and SCO ODT 3.0 have their own names for install.
6367 <    # Don't use installbsd from OSF since it installs stuff as root
6368 <    # by default.
6369 <    for ac_prog in ginstall scoinst install; do
6370 <      for ac_exec_ext in '' $ac_executable_extensions; do
6371 <        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
6372 <          if test $ac_prog = install &&
6373 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6374 <            # AIX install.  It has an incompatible calling convention.
6375 <            :
6376 <          elif test $ac_prog = install &&
6377 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6378 <            # program-specific install script used by HP pwplus--don't use.
6379 <            :
6380 <          else
6381 <            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
6382 <            break 3
6383 <          fi
6384 <        fi
6385 <      done
6386 <    done
6387 <    ;;
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
6478 <
6479 < fi
6480 < fi
6481 < RANLIB=$ac_cv_prog_RANLIB
6482 < if test -n "$RANLIB"; then
6483 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
6484 < echo "${ECHO_T}$RANLIB" >&6
6485 < else
6486 <  echo "$as_me:$LINENO: result: no" >&5
6487 < echo "${ECHO_T}no" >&6
6488 < fi
6489 <
6490 < fi
6491 < if test -z "$ac_cv_prog_RANLIB"; then
6492 <  ac_ct_RANLIB=$RANLIB
6493 <  # Extract the first word of "ranlib", so it can be a program name with args.
6494 < set dummy ranlib; ac_word=$2
6495 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6496 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6497 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
6498 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6499 < else
6500 <  if test -n "$ac_ct_RANLIB"; then
6501 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
6502 < else
6503 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6504 < for as_dir in $PATH
6505 < do
6506 <  IFS=$as_save_IFS
6507 <  test -z "$as_dir" && as_dir=.
6508 <  for ac_exec_ext in '' $ac_executable_extensions; do
6509 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6510 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
6511 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6512 <    break 2
6513 <  fi
6514 < done
6515 < done
6516 <
6517 <  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
6518 < fi
6519 < fi
6520 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6521 < if test -n "$ac_ct_RANLIB"; then
6522 <  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
6523 < echo "${ECHO_T}$ac_ct_RANLIB" >&6
6524 < else
6525 <  echo "$as_me:$LINENO: result: no" >&5
6526 < echo "${ECHO_T}no" >&6
6527 < fi
6528 <
6529 <  RANLIB=$ac_ct_RANLIB
6530 < else
6531 <  RANLIB="$ac_cv_prog_RANLIB"
6532 < fi
6533 <
6534 < for ac_prog in 'bison -y' byacc
6535 < do
6536 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
6537 < set dummy $ac_prog; ac_word=$2
6538 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6539 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6540 < if test "${ac_cv_prog_YACC+set}" = set; then
6541 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6542 < else
6543 <  if test -n "$YACC"; then
6544 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
6545 < else
6546 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6547 < for as_dir in $PATH
6548 < do
6549 <  IFS=$as_save_IFS
6550 <  test -z "$as_dir" && as_dir=.
6551 <  for ac_exec_ext in '' $ac_executable_extensions; do
6552 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6553 <    ac_cv_prog_YACC="$ac_prog"
6554 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6555 <    break 2
6556 <  fi
6557 < done
6558 < done
6559 <
6560 < fi
6561 < fi
6562 < YACC=$ac_cv_prog_YACC
6563 < if test -n "$YACC"; then
6564 <  echo "$as_me:$LINENO: result: $YACC" >&5
6565 < echo "${ECHO_T}$YACC" >&6
6566 < else
6567 <  echo "$as_me:$LINENO: result: no" >&5
6568 < echo "${ECHO_T}no" >&6
6569 < fi
6570 <
6571 <  test -n "$YACC" && break
6572 < done
6573 < test -n "$YACC" || YACC="yacc"
6574 <
6575 < for ac_prog in flex lex
6576 < do
6577 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
6578 < set dummy $ac_prog; ac_word=$2
6579 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6580 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6581 < if test "${ac_cv_prog_LEX+set}" = set; then
6582 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6583 < else
6584 <  if test -n "$LEX"; then
6585 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
6586 < else
6587 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6588 < for as_dir in $PATH
6589 < do
6590 <  IFS=$as_save_IFS
6591 <  test -z "$as_dir" && as_dir=.
6592 <  for ac_exec_ext in '' $ac_executable_extensions; do
6593 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6594 <    ac_cv_prog_LEX="$ac_prog"
6595 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6596 <    break 2
6597 <  fi
6598 < done
6599 < done
6600 <
6601 < fi
6602 < fi
6603 < LEX=$ac_cv_prog_LEX
6604 < if test -n "$LEX"; then
6605 <  echo "$as_me:$LINENO: result: $LEX" >&5
6606 < echo "${ECHO_T}$LEX" >&6
6607 < else
6608 <  echo "$as_me:$LINENO: result: no" >&5
6609 < echo "${ECHO_T}no" >&6
6610 < fi
6611 <
6612 <  test -n "$LEX" && break
6613 < done
6614 < test -n "$LEX" || LEX=":"
6615 <
6616 < if test -z "$LEXLIB"
6617 < then
6618 <  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
6619 < echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
6620 < if test "${ac_cv_lib_fl_yywrap+set}" = set; then
6621 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6622 < else
6623 <  ac_check_lib_save_LIBS=$LIBS
6624 < LIBS="-lfl  $LIBS"
6625 < cat >conftest.$ac_ext <<_ACEOF
6626 < #line $LINENO "configure"
6627 < /* confdefs.h.  */
6628 < _ACEOF
6629 < cat confdefs.h >>conftest.$ac_ext
6630 < cat >>conftest.$ac_ext <<_ACEOF
6631 < /* end confdefs.h.  */
6632 <
6633 < /* Override any gcc2 internal prototype to avoid an error.  */
6634 < #ifdef __cplusplus
6635 < extern "C"
6636 < #endif
6637 < /* We use char because int might match the return type of a gcc2
6638 <   builtin and then its argument prototype would still apply.  */
6639 < char yywrap ();
6640 < int
6641 < main ()
6642 < {
6643 < yywrap ();
6644 <  ;
6645 <  return 0;
6646 < }
6647 < _ACEOF
6648 < rm -f conftest.$ac_objext conftest$ac_exeext
6649 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6650 <  (eval $ac_link) 2>&5
6651 <  ac_status=$?
6652 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6653 <  (exit $ac_status); } &&
6654 <         { ac_try='test -s conftest$ac_exeext'
6655 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6656 <  (eval $ac_try) 2>&5
6657 <  ac_status=$?
6658 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6659 <  (exit $ac_status); }; }; then
6660 <  ac_cv_lib_fl_yywrap=yes
6661 < else
6662 <  echo "$as_me: failed program was:" >&5
6663 < sed 's/^/| /' conftest.$ac_ext >&5
6664 <
6665 < ac_cv_lib_fl_yywrap=no
6666 < fi
6667 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
6668 < LIBS=$ac_check_lib_save_LIBS
6669 < fi
6670 < echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
6671 < echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
6672 < if test $ac_cv_lib_fl_yywrap = yes; then
6673 <  LEXLIB="-lfl"
6674 < else
6675 <  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
6676 < echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
6677 < if test "${ac_cv_lib_l_yywrap+set}" = set; then
6678 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6679 < else
6680 <  ac_check_lib_save_LIBS=$LIBS
6681 < LIBS="-ll  $LIBS"
6682 < cat >conftest.$ac_ext <<_ACEOF
6683 < #line $LINENO "configure"
6684 < /* confdefs.h.  */
6685 < _ACEOF
6686 < cat confdefs.h >>conftest.$ac_ext
6687 < cat >>conftest.$ac_ext <<_ACEOF
6688 < /* end confdefs.h.  */
6689 <
6690 < /* Override any gcc2 internal prototype to avoid an error.  */
6691 < #ifdef __cplusplus
6692 < extern "C"
6693 < #endif
6694 < /* We use char because int might match the return type of a gcc2
6695 <   builtin and then its argument prototype would still apply.  */
6696 < char yywrap ();
6697 < int
6698 < main ()
6699 < {
6700 < yywrap ();
6701 <  ;
6702 <  return 0;
6703 < }
6704 < _ACEOF
6705 < rm -f conftest.$ac_objext conftest$ac_exeext
6706 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6707 <  (eval $ac_link) 2>&5
6708 <  ac_status=$?
6709 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6710 <  (exit $ac_status); } &&
6711 <         { ac_try='test -s conftest$ac_exeext'
6712 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6713 <  (eval $ac_try) 2>&5
6714 <  ac_status=$?
6715 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6716 <  (exit $ac_status); }; }; then
6717 <  ac_cv_lib_l_yywrap=yes
13202 > fi
13203 > echo "$as_me:$LINENO: result: $ac_m_cpu_750" >&5
13204 > echo "${ECHO_T}$ac_m_cpu_750" >&6
13205 > if test "$ac_m_cpu_750" = yes; then
13206 >        :
13207 >        CPU_FLAGS=-mcpu=750
13208   else
13209 <  echo "$as_me: failed program was:" >&5
6720 < sed 's/^/| /' conftest.$ac_ext >&5
13209 >        :
13210  
6722 ac_cv_lib_l_yywrap=no
13211   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
13212  
13213 < fi
13213 > else
13214 >        :
13215  
13216   fi
13217  
13218 < if test "x$LEX" != "x:"; then
13219 <  echo "$as_me:$LINENO: checking lex output file root" >&5
13220 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
13221 < if test "${ac_cv_prog_lex_root+set}" = set; then
13218 >                fi
13219 >                if test -z "$CPU_FLAGS"; then
13220 >
13221 >
13222 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
13223 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
13224 > if test "${ac_m_cpu_powerpc+set}" = set; then
13225    echo $ECHO_N "(cached) $ECHO_C" >&6
13226   else
13227 <  # The minimal lex program is just a single line: %%.  But some broken lexes
13228 < # (Solaris, I think it was) want two %% lines, so accommodate them.
13229 < 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
13227 >  echo 'void f(){}' > conftest.cpp
13228 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
13229 >        ac_m_cpu_powerpc=yes
13230   else
13231 <  { { 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; }; }
13231 >        ac_m_cpu_powerpc=no
13232   fi
13233 < 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
13233 > rm -f conftest*
13234  
13235 < echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
13236 < echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
13237 < if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
13238 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13235 > fi
13236 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
13237 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
13238 > if test "$ac_m_cpu_powerpc" = yes; then
13239 >        :
13240 >        CPU_FLAGS=-mcpu=powerpc
13241   else
13242 <  # 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
13242 >        :
13243  
13244   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"
13245  
13246 < fi
13247 < 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
13246 >                fi
13247 >                if test -z "$CPU_FLAGS"; then
13248  
6811 cat >>confdefs.h <<\_ACEOF
6812 #define YYTEXT_POINTER 1
6813 _ACEOF
13249  
13250 < fi
13251 <
13252 < 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
13250 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
13251 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
13252 > if test "${ac_m_powerpc+set}" = set; then
13253    echo $ECHO_N "(cached) $ECHO_C" >&6
13254   else
13255 <  if test -n "$AR"; then
13256 <  ac_cv_prog_AR="$AR" # Let the user override the test.
13255 >  echo 'void f(){}' > conftest.cpp
13256 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
13257 >        ac_m_powerpc=yes
13258   else
13259 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13260 < for as_dir in $PATH
13261 < 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
13259 >        ac_m_powerpc=no
13260 > fi
13261 > rm -f conftest*
13262  
6842  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
13263   fi
13264 < fi
13265 < AR=$ac_cv_prog_AR
13266 < if test -n "$AR"; then
13267 <  echo "$as_me:$LINENO: result: $AR" >&5
13268 < echo "${ECHO_T}$AR" >&6
13264 > echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
13265 > echo "${ECHO_T}$ac_m_powerpc" >&6
13266 > if test "$ac_m_powerpc" = yes; then
13267 >        :
13268 >        CPU_FLAGS=-mpowerpc
13269   else
13270 <  echo "$as_me:$LINENO: result: no" >&5
13271 < echo "${ECHO_T}no" >&6
13270 >        :
13271 >
13272   fi
13273  
13274 < if test "$AR" = "NONE"; then
13275 <  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
13276 < 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.
13274 >                fi
13275 >          esac
13276 >  fi
13277  
13278 < _ACEOF
13278 >  if test -n "$CPU_FLAGS"; then
13279 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
13280 >  fi
13281  
13282 < # The following way of writing the cache mishandles newlines in values,
13283 < # but we know of no workaround that is simple, portable, and efficient.
13284 < # So, don't put newlines in cache variables' values.
13285 < # Ultrix sh set writes to stderr and can't be redirected directly,
13286 < # and sets the high bit in the cache file unless we assign to the vars.
13287 < {
13288 <  (set) 2>&1 |
13289 <    case `(ac_space=' '; set | grep ac_space) 2>&1` in
13290 <    *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"
13282 >  if test -z "$CXXFLAGS"; then
13283 >        echo ""
13284 >        echo "**********************************************************"
13285 >        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
13286 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
13287 >        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
13288 >        echo "**********************************************************"
13289 >        echo ""
13290 >        CXXFLAGS="-O3"
13291    fi
6910 fi
6911 rm -f confcache
6912  exit 1
6913 fi
13292  
13293 < # Extract the first word of "ps", so it can be a program name with args.
13294 < set dummy ps; ac_word=$2
13295 < echo "$as_me:$LINENO: checking for $ac_word" >&5
13296 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13297 < if test "${ac_cv_path_PS+set}" = set; then
13293 >
13294 >
13295 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
13296 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
13297 > if test "${ac_guessed_cxxflags+set}" = set; then
13298    echo $ECHO_N "(cached) $ECHO_C" >&6
13299   else
13300 <  case $PS in
13301 <  [\\/]* | ?:[\\/]*)
13302 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
13303 <  ;;
13304 <  *)
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
13300 >  echo 'void f(){}' > conftest.cpp
13301 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
13302 >        ac_guessed_cxxflags=yes
13303 > else
13304 >        ac_guessed_cxxflags=no
13305   fi
13306 < PS=$ac_cv_path_PS
13306 > rm -f conftest*
13307  
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
13308   fi
13309 + echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
13310 + echo "${ECHO_T}$ac_guessed_cxxflags" >&6
13311 + if test "$ac_guessed_cxxflags" = yes; then
13312 +        :
13313  
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
13314   else
13315 +        :
13316  
13317 <        if $PS -ef -o rss > /dev/null 2>&1; then
13318 <                ac_cv_prog_ps_ef=yes
13319 <        else
13320 <                ac_cv_prog_ps_ef=no
13321 <        fi
13322 <        if $PS ax -o rss > /dev/null 2>&1; then
13323 <                ac_cv_prog_ps_ax=yes
13324 <        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
13317 >        echo ""
13318 >        echo "**********************************************************"
13319 >        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
13320 >        echo "* your compiler.                                         *"
13321 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
13322 >        echo "**********************************************************"
13323 >        echo ""
13324 >        CXXFLAGS=""
13325  
13326   fi
6983 echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
6984 echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
13327  
6986 cat >>confdefs.h <<_ACEOF
6987 #define PS $PS
6988 _ACEOF
13328  
13329 + fi
13330  
13331 < cat >>confdefs.h <<_ACEOF
13332 < #define PSTYPE $ac_cv_prog_ps_syntax
13331 >     ;;
13332 > esac
13333 >
13334 >
13335 > cat >>confdefs.h <<\_ACEOF
13336 > #define OBAPI
13337   _ACEOF
13338  
13339  
# Line 7020 | Line 13364 | MPI_INC_DIR="$MPI/include"
13364  
13365  
13366  
13367 + ac_ext=c
13368 + ac_cpp='$CPP $CPPFLAGS'
13369 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13370 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13371 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
13372 +
13373   echo "$as_me:$LINENO: checking for mpi.h" >&5
13374   echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
13375   have_mpi_h=0
13376 < echo '#include <mpi.h>' > conftest.cc
13377 < if test -z "`${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1`"; then
13376 > rm -f conftest*
13377 > echo '#include <mpi.h>' > conftest.c
13378 > if ${CC} -I${MPI_INC_DIR} -c conftest.c 2>&1 ; then
13379          echo "$as_me:$LINENO: result: yes" >&5
13380   echo "${ECHO_T}yes" >&6
13381          have_mpi_h=1
13382   else
13383 +        if test -s conftest.out ; then
13384 +                cat conftest.out >> config.log
13385 +        fi
13386          echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
13387   echo "${ECHO_T}no! Check MPI include paths" >&6
13388          USE_MPI="no"
# Line 7044 | Line 13398 | echo $ECHO_N "checking whether mpif.h is usable... $EC
13398  
13399   echo "$as_me:$LINENO: checking whether mpif.h is usable" >&5
13400   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13401 +
13402 +
13403 + ac_ext=${FC_SRCEXT-f}
13404 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
13405 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
13406 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
13407 +
13408 + ac_save_ext=$ac_ext
13409 + ac_ext=F90
13410 + ac_save_FCFLAGS=$FCFLAGS
13411   have_mpif_h=0
13412   rm -f conftest*
13413 < cat >conftest.f90 <<EOF
13413 > cat >conftest.$ac_ext <<EOF
13414   program main
13415     include 'mpif.h'
13416   end
13417   EOF
13418 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13418 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13419          echo "$as_me:$LINENO: result: yes" >&5
13420   echo "${ECHO_T}yes" >&6
13421          MPI_F90_INC="$MPI_INC_DIR"
# Line 7073 | Line 13437 | fi
13437   _ACEOF
13438  
13439   fi
13440 + FCFLAGS=$ac_save_FCFLAGS
13441 + ac_ext=$ac_save_ext
13442 + ac_ext=c
13443 + ac_cpp='$CPP $CPPFLAGS'
13444 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13445 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13446 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
13447  
13448 +
13449   ac_ext=c
13450   ac_cpp='$CPP $CPPFLAGS'
13451   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 7081 | Line 13453 | ac_save_LDFLAGS=$LDFLAGS
13453   ac_compiler_gnu=$ac_cv_c_compiler_gnu
13454  
13455   ac_save_LDFLAGS=$LDFLAGS
13456 < LDFLAGS="${LDFLAGS} -L${MPI_LIB_DIR} "
13456 > LDFLAGS="-L${MPI_LIB_DIR} ${LDFLAGS} "
13457  
13458   if test x = x"$MPI_LIB"; then
13459          echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
# Line 7092 | Line 13464 | cat >conftest.$ac_ext <<_ACEOF
13464    ac_check_lib_save_LIBS=$LIBS
13465   LIBS="-lmpich  $LIBS"
13466   cat >conftest.$ac_ext <<_ACEOF
7095 #line $LINENO "configure"
13467   /* confdefs.h.  */
13468   _ACEOF
13469   cat confdefs.h >>conftest.$ac_ext
# Line 7106 | Line 13477 | char MPI_Init ();
13477   /* We use char because int might match the return type of a gcc2
13478     builtin and then its argument prototype would still apply.  */
13479   char MPI_Init ();
13480 + #ifdef FC_DUMMY_MAIN
13481 + #ifndef FC_DUMMY_MAIN_EQ_F77
13482 + #  ifdef __cplusplus
13483 +     extern "C"
13484 + #  endif
13485 +   int FC_DUMMY_MAIN() { return 1; }
13486 + #endif
13487 + #endif
13488   int
13489   main ()
13490   {
# Line 7116 | Line 13495 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13495   _ACEOF
13496   rm -f conftest.$ac_objext conftest$ac_exeext
13497   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13498 <  (eval $ac_link) 2>&5
13498 >  (eval $ac_link) 2>conftest.er1
13499    ac_status=$?
13500 +  grep -v '^ *+' conftest.er1 >conftest.err
13501 +  rm -f conftest.er1
13502 +  cat conftest.err >&5
13503    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13504    (exit $ac_status); } &&
13505 <         { ac_try='test -s conftest$ac_exeext'
13505 >         { ac_try='test -z "$ac_c_werror_flag"
13506 >                         || test ! -s conftest.err'
13507    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13508    (eval $ac_try) 2>&5
13509    ac_status=$?
13510    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13511 +  (exit $ac_status); }; } &&
13512 +         { ac_try='test -s conftest$ac_exeext'
13513 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13514 +  (eval $ac_try) 2>&5
13515 +  ac_status=$?
13516 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13517    (exit $ac_status); }; }; then
13518    ac_cv_lib_mpich_MPI_Init=yes
13519   else
# Line 7133 | Line 13522 | fi
13522  
13523   ac_cv_lib_mpich_MPI_Init=no
13524   fi
13525 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
13525 > rm -f conftest.err conftest.$ac_objext \
13526 >      conftest$ac_exeext conftest.$ac_ext
13527   LIBS=$ac_check_lib_save_LIBS
13528   fi
13529   echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
# Line 7143 | Line 13533 | fi
13533   fi
13534  
13535   fi
13536 + $as_unset ac_cv_lib_mpich_MPI_Init
13537   if test x = x"$MPI_LIB"; then
13538 +        echo "$as_me:$LINENO: checking for MPI_Init in -lpmpich" >&5
13539 + echo $ECHO_N "checking for MPI_Init in -lpmpich... $ECHO_C" >&6
13540 + if test "${ac_cv_lib_pmpich_MPI_Init+set}" = set; then
13541 +  echo $ECHO_N "(cached) $ECHO_C" >&6
13542 + else
13543 +  ac_check_lib_save_LIBS=$LIBS
13544 + LIBS="-lpmpich -lmpich -lpmpich -lmpich $LIBS"
13545 + cat >conftest.$ac_ext <<_ACEOF
13546 + /* confdefs.h.  */
13547 + _ACEOF
13548 + cat confdefs.h >>conftest.$ac_ext
13549 + cat >>conftest.$ac_ext <<_ACEOF
13550 + /* end confdefs.h.  */
13551 +
13552 + /* Override any gcc2 internal prototype to avoid an error.  */
13553 + #ifdef __cplusplus
13554 + extern "C"
13555 + #endif
13556 + /* We use char because int might match the return type of a gcc2
13557 +   builtin and then its argument prototype would still apply.  */
13558 + char MPI_Init ();
13559 + #ifdef FC_DUMMY_MAIN
13560 + #ifndef FC_DUMMY_MAIN_EQ_F77
13561 + #  ifdef __cplusplus
13562 +     extern "C"
13563 + #  endif
13564 +   int FC_DUMMY_MAIN() { return 1; }
13565 + #endif
13566 + #endif
13567 + int
13568 + main ()
13569 + {
13570 + MPI_Init ();
13571 +  ;
13572 +  return 0;
13573 + }
13574 + _ACEOF
13575 + rm -f conftest.$ac_objext conftest$ac_exeext
13576 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13577 +  (eval $ac_link) 2>conftest.er1
13578 +  ac_status=$?
13579 +  grep -v '^ *+' conftest.er1 >conftest.err
13580 +  rm -f conftest.er1
13581 +  cat conftest.err >&5
13582 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13583 +  (exit $ac_status); } &&
13584 +         { ac_try='test -z "$ac_c_werror_flag"
13585 +                         || test ! -s conftest.err'
13586 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13587 +  (eval $ac_try) 2>&5
13588 +  ac_status=$?
13589 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13590 +  (exit $ac_status); }; } &&
13591 +         { ac_try='test -s conftest$ac_exeext'
13592 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13593 +  (eval $ac_try) 2>&5
13594 +  ac_status=$?
13595 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13596 +  (exit $ac_status); }; }; then
13597 +  ac_cv_lib_pmpich_MPI_Init=yes
13598 + else
13599 +  echo "$as_me: failed program was:" >&5
13600 + sed 's/^/| /' conftest.$ac_ext >&5
13601 +
13602 + ac_cv_lib_pmpich_MPI_Init=no
13603 + fi
13604 + rm -f conftest.err conftest.$ac_objext \
13605 +      conftest$ac_exeext conftest.$ac_ext
13606 + LIBS=$ac_check_lib_save_LIBS
13607 + fi
13608 + echo "$as_me:$LINENO: result: $ac_cv_lib_pmpich_MPI_Init" >&5
13609 + echo "${ECHO_T}$ac_cv_lib_pmpich_MPI_Init" >&6
13610 + if test $ac_cv_lib_pmpich_MPI_Init = yes; then
13611 +  MPI_LIB="-lpmpich -lmpich -lpmpich -lmpich"
13612 + fi
13613 +
13614 + fi
13615 + if test x = x"$MPI_LIB"; then
13616          echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13617   echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13618   if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
# Line 7152 | Line 13621 | cat >conftest.$ac_ext <<_ACEOF
13621    ac_check_lib_save_LIBS=$LIBS
13622   LIBS="-lmpi  $LIBS"
13623   cat >conftest.$ac_ext <<_ACEOF
7155 #line $LINENO "configure"
13624   /* confdefs.h.  */
13625   _ACEOF
13626   cat confdefs.h >>conftest.$ac_ext
# Line 7166 | Line 13634 | char MPI_Init ();
13634   /* We use char because int might match the return type of a gcc2
13635     builtin and then its argument prototype would still apply.  */
13636   char MPI_Init ();
13637 + #ifdef FC_DUMMY_MAIN
13638 + #ifndef FC_DUMMY_MAIN_EQ_F77
13639 + #  ifdef __cplusplus
13640 +     extern "C"
13641 + #  endif
13642 +   int FC_DUMMY_MAIN() { return 1; }
13643 + #endif
13644 + #endif
13645   int
13646   main ()
13647   {
# Line 7176 | Line 13652 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13652   _ACEOF
13653   rm -f conftest.$ac_objext conftest$ac_exeext
13654   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13655 <  (eval $ac_link) 2>&5
13655 >  (eval $ac_link) 2>conftest.er1
13656    ac_status=$?
13657 +  grep -v '^ *+' conftest.er1 >conftest.err
13658 +  rm -f conftest.er1
13659 +  cat conftest.err >&5
13660    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13661    (exit $ac_status); } &&
13662 <         { ac_try='test -s conftest$ac_exeext'
13662 >         { ac_try='test -z "$ac_c_werror_flag"
13663 >                         || test ! -s conftest.err'
13664    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13665    (eval $ac_try) 2>&5
13666    ac_status=$?
13667    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13668 +  (exit $ac_status); }; } &&
13669 +         { ac_try='test -s conftest$ac_exeext'
13670 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13671 +  (eval $ac_try) 2>&5
13672 +  ac_status=$?
13673 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13674    (exit $ac_status); }; }; then
13675    ac_cv_lib_mpi_MPI_Init=yes
13676   else
# Line 7193 | Line 13679 | fi
13679  
13680   ac_cv_lib_mpi_MPI_Init=no
13681   fi
13682 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
13682 > rm -f conftest.err conftest.$ac_objext \
13683 >      conftest$ac_exeext conftest.$ac_ext
13684   LIBS=$ac_check_lib_save_LIBS
13685   fi
13686   echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
# Line 7211 | Line 13698 | else
13698    echo $ECHO_N "(cached) $ECHO_C" >&6
13699   else
13700    ac_check_lib_save_LIBS=$LIBS
13701 < LIBS="-lmpi "-llam" $LIBS"
13701 > LIBS="-lmpi -llam $LIBS"
13702   cat >conftest.$ac_ext <<_ACEOF
7216 #line $LINENO "configure"
13703   /* confdefs.h.  */
13704   _ACEOF
13705   cat confdefs.h >>conftest.$ac_ext
# Line 7227 | Line 13713 | char MPI_Init ();
13713   /* We use char because int might match the return type of a gcc2
13714     builtin and then its argument prototype would still apply.  */
13715   char MPI_Init ();
13716 + #ifdef FC_DUMMY_MAIN
13717 + #ifndef FC_DUMMY_MAIN_EQ_F77
13718 + #  ifdef __cplusplus
13719 +     extern "C"
13720 + #  endif
13721 +   int FC_DUMMY_MAIN() { return 1; }
13722 + #endif
13723 + #endif
13724   int
13725   main ()
13726   {
# Line 7237 | Line 13731 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13731   _ACEOF
13732   rm -f conftest.$ac_objext conftest$ac_exeext
13733   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13734 <  (eval $ac_link) 2>&5
13734 >  (eval $ac_link) 2>conftest.er1
13735 >  ac_status=$?
13736 >  grep -v '^ *+' conftest.er1 >conftest.err
13737 >  rm -f conftest.er1
13738 >  cat conftest.err >&5
13739 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13740 >  (exit $ac_status); } &&
13741 >         { ac_try='test -z "$ac_c_werror_flag"
13742 >                         || test ! -s conftest.err'
13743 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13744 >  (eval $ac_try) 2>&5
13745 >  ac_status=$?
13746 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13747 >  (exit $ac_status); }; } &&
13748 >         { ac_try='test -s conftest$ac_exeext'
13749 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13750 >  (eval $ac_try) 2>&5
13751 >  ac_status=$?
13752 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13753 >  (exit $ac_status); }; }; then
13754 >  ac_cv_lib_mpi_MPI_Init=yes
13755 > else
13756 >  echo "$as_me: failed program was:" >&5
13757 > sed 's/^/| /' conftest.$ac_ext >&5
13758 >
13759 > ac_cv_lib_mpi_MPI_Init=no
13760 > fi
13761 > rm -f conftest.err conftest.$ac_objext \
13762 >      conftest$ac_exeext conftest.$ac_ext
13763 > LIBS=$ac_check_lib_save_LIBS
13764 > fi
13765 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13766 > echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13767 > if test $ac_cv_lib_mpi_MPI_Init = yes; then
13768 >  MPI_LIB="-lmpi -llam"
13769 > fi
13770 >
13771 > fi
13772 > $as_unset ac_cv_lib_mpi_MPI_Init
13773 > if test x = x"$MPI_LIB"; then
13774 > echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13775 > echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13776 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13777 >  echo $ECHO_N "(cached) $ECHO_C" >&6
13778 > else
13779 >  ac_check_lib_save_LIBS=$LIBS
13780 > LIBS="-lmpi -llam -lpthread $LIBS"
13781 > cat >conftest.$ac_ext <<_ACEOF
13782 > /* confdefs.h.  */
13783 > _ACEOF
13784 > cat confdefs.h >>conftest.$ac_ext
13785 > cat >>conftest.$ac_ext <<_ACEOF
13786 > /* end confdefs.h.  */
13787 >
13788 > /* Override any gcc2 internal prototype to avoid an error.  */
13789 > #ifdef __cplusplus
13790 > extern "C"
13791 > #endif
13792 > /* We use char because int might match the return type of a gcc2
13793 >   builtin and then its argument prototype would still apply.  */
13794 > char MPI_Init ();
13795 > #ifdef FC_DUMMY_MAIN
13796 > #ifndef FC_DUMMY_MAIN_EQ_F77
13797 > #  ifdef __cplusplus
13798 >     extern "C"
13799 > #  endif
13800 >   int FC_DUMMY_MAIN() { return 1; }
13801 > #endif
13802 > #endif
13803 > int
13804 > main ()
13805 > {
13806 > MPI_Init ();
13807 >  ;
13808 >  return 0;
13809 > }
13810 > _ACEOF
13811 > rm -f conftest.$ac_objext conftest$ac_exeext
13812 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13813 >  (eval $ac_link) 2>conftest.er1
13814 >  ac_status=$?
13815 >  grep -v '^ *+' conftest.er1 >conftest.err
13816 >  rm -f conftest.er1
13817 >  cat conftest.err >&5
13818 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13819 >  (exit $ac_status); } &&
13820 >         { ac_try='test -z "$ac_c_werror_flag"
13821 >                         || test ! -s conftest.err'
13822 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13823 >  (eval $ac_try) 2>&5
13824 >  ac_status=$?
13825 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13826 >  (exit $ac_status); }; } &&
13827 >         { ac_try='test -s conftest$ac_exeext'
13828 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13829 >  (eval $ac_try) 2>&5
13830 >  ac_status=$?
13831 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13832 >  (exit $ac_status); }; }; then
13833 >  ac_cv_lib_mpi_MPI_Init=yes
13834 > else
13835 >  echo "$as_me: failed program was:" >&5
13836 > sed 's/^/| /' conftest.$ac_ext >&5
13837 >
13838 > ac_cv_lib_mpi_MPI_Init=no
13839 > fi
13840 > rm -f conftest.err conftest.$ac_objext \
13841 >      conftest$ac_exeext conftest.$ac_ext
13842 > LIBS=$ac_check_lib_save_LIBS
13843 > fi
13844 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13845 > echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13846 > if test $ac_cv_lib_mpi_MPI_Init = yes; then
13847 >  MPI_LIB="-lmpi -llam -lpthread"
13848 > else
13849 >
13850 >             { { echo "$as_me:$LINENO: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&5
13851 > echo "$as_me: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&2;}
13852 >   { (exit 1); exit 1; }; }
13853 >             USE_MPI="no"
13854 >
13855 > fi
13856 >
13857 > fi
13858 >
13859 >
13860 >
13861 > echo "$as_me:$LINENO: checking for MPI Fortran library" >&5
13862 > echo $ECHO_N "checking for MPI Fortran library... $ECHO_C" >&6
13863 > MPI_F90_LIB=""
13864 > if test -f "$MPI_LIB_DIR/libfmpich.a" ; then
13865 >        MPI_F90_LIB="-lfmpich"
13866 > elif test -f "$MPI_LIB_DIR/liblamf77mpi.a" ; then
13867 >        MPI_F90_LIB="-llamf77mpi"
13868 > else
13869 >                        MPI_F90_LIB="  "
13870 > fi
13871 > echo "$as_me:$LINENO: result: found $MPI_F90_LIB" >&5
13872 > echo "${ECHO_T}found $MPI_F90_LIB" >&6
13873 >
13874 >
13875 > fi
13876 >
13877 >
13878 >
13879 > acx_cgal_found=no
13880 >
13881 > # Check whether --with-cgalmakefile or --without-cgalmakefile was given.
13882 > if test "${with_cgalmakefile+set}" = set; then
13883 >  withval="$with_cgalmakefile"
13884 >
13885 > fi;
13886 > case $with_cgalmakefile in
13887 >        yes | "") ;;
13888 >        no) acx_cgal_found=disable ;;
13889 >        -* | */* | *.a | *.so | *.so.* | *.o) CGAL_MAKEFILE="$with_cgalmakefile" ;;
13890 >        *) CGAL_MAKEFILE="$with_cgalmakefile" ;;
13891 > esac
13892 >
13893 > if test "$acx_cgal_found" == no; then
13894 >    echo "$as_me:$LINENO: checking CGAL_MAKEFILE" >&5
13895 > echo $ECHO_N "checking CGAL_MAKEFILE... $ECHO_C" >&6
13896 >
13897 >    if test \! -z "$CGAL_MAKEFILE"; then
13898 >
13899 >        if test -e "$CGAL_MAKEFILE"; then
13900 >            tname=`mktemp /tmp/cgal_makefile_dsrXXXXXX`
13901 >
13902 > cat > $tname << _ACEOF
13903 > include $CGAL_MAKEFILE
13904 >
13905 > cppflags:
13906 >        @echo \$(CGAL_CXXFLAGS)
13907 >
13908 > cxxflags:
13909 >        @echo
13910 > ldflags:
13911 >        @echo \$(CGAL_LDFLAGS)
13912 > _ACEOF
13913 >            CGAL_CPPFLAGS="`make -s -f $tname cppflags`"
13914 >            CGAL_CXXFLAGS="`make -s -f $tname cxxflags`"
13915 >            CGAL_LDFLAGST="`make -s -f $tname ldflags`"
13916 >            for i in $CGAL_LDFLAGST; do
13917 >                if test `echo $i| grep -c ^-l`; then
13918 >                    CGAL_LIBS="$CGAL_LIBS $i"
13919 >                else
13920 >                    CGAL_LDFLAGS="$CGAL_LDFLAGS $i"
13921 >                fi
13922 >            done
13923 >            rm -f $tname
13924 >            echo "$as_me:$LINENO: result: yes" >&5
13925 > echo "${ECHO_T}yes" >&6
13926 >            acx_cgal_found=yes
13927 >                                   else
13928 >            echo "$as_me:$LINENO: result: invalid" >&5
13929 > echo "${ECHO_T}invalid" >&6
13930 >            { { echo "$as_me:$LINENO: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&5
13931 > echo "$as_me: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&2;}
13932 >   { (exit 1); exit 1; }; }
13933 >        fi
13934 >    else
13935 >        echo "$as_me:$LINENO: result: not defined" >&5
13936 > echo "${ECHO_T}not defined" >&6
13937 >    fi
13938 > fi
13939 >
13940 > if test "$acx_cgal_found" == no; then
13941 >        if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
13942 >  echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
13943 > echo $ECHO_N "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... $ECHO_C" >&6
13944 > if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
13945 >  echo $ECHO_N "(cached) $ECHO_C" >&6
13946 > fi
13947 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
13948 > echo "${ECHO_T}$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6
13949 > else
13950 >  # Is the header compilable?
13951 > echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability" >&5
13952 > echo $ECHO_N "checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability... $ECHO_C" >&6
13953 > cat >conftest.$ac_ext <<_ACEOF
13954 > /* confdefs.h.  */
13955 > _ACEOF
13956 > cat confdefs.h >>conftest.$ac_ext
13957 > cat >>conftest.$ac_ext <<_ACEOF
13958 > /* end confdefs.h.  */
13959 > $ac_includes_default
13960 > #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
13961 > _ACEOF
13962 > rm -f conftest.$ac_objext
13963 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13964 >  (eval $ac_compile) 2>conftest.er1
13965    ac_status=$?
13966 +  grep -v '^ *+' conftest.er1 >conftest.err
13967 +  rm -f conftest.er1
13968 +  cat conftest.err >&5
13969    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13970 <  (exit $ac_status); } &&
13971 <         { ac_try='test -s conftest$ac_exeext'
13970 >  (exit $ac_status); } &&
13971 >         { ac_try='test -z "$ac_c_werror_flag"
13972 >                         || test ! -s conftest.err'
13973 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13974 >  (eval $ac_try) 2>&5
13975 >  ac_status=$?
13976 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13977 >  (exit $ac_status); }; } &&
13978 >         { ac_try='test -s conftest.$ac_objext'
13979 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13980 >  (eval $ac_try) 2>&5
13981 >  ac_status=$?
13982 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
13983 >  (exit $ac_status); }; }; then
13984 >  ac_header_compiler=yes
13985 > else
13986 >  echo "$as_me: failed program was:" >&5
13987 > sed 's/^/| /' conftest.$ac_ext >&5
13988 >
13989 > ac_header_compiler=no
13990 > fi
13991 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
13992 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
13993 > echo "${ECHO_T}$ac_header_compiler" >&6
13994 >
13995 > # Is the header present?
13996 > echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence" >&5
13997 > echo $ECHO_N "checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence... $ECHO_C" >&6
13998 > cat >conftest.$ac_ext <<_ACEOF
13999 > /* confdefs.h.  */
14000 > _ACEOF
14001 > cat confdefs.h >>conftest.$ac_ext
14002 > cat >>conftest.$ac_ext <<_ACEOF
14003 > /* end confdefs.h.  */
14004 > #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
14005 > _ACEOF
14006 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
14007 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
14008 >  ac_status=$?
14009 >  grep -v '^ *+' conftest.er1 >conftest.err
14010 >  rm -f conftest.er1
14011 >  cat conftest.err >&5
14012 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14013 >  (exit $ac_status); } >/dev/null; then
14014 >  if test -s conftest.err; then
14015 >    ac_cpp_err=$ac_c_preproc_warn_flag
14016 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
14017 >  else
14018 >    ac_cpp_err=
14019 >  fi
14020 > else
14021 >  ac_cpp_err=yes
14022 > fi
14023 > if test -z "$ac_cpp_err"; then
14024 >  ac_header_preproc=yes
14025 > else
14026 >  echo "$as_me: failed program was:" >&5
14027 > sed 's/^/| /' conftest.$ac_ext >&5
14028 >
14029 >  ac_header_preproc=no
14030 > fi
14031 > rm -f conftest.err conftest.$ac_ext
14032 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
14033 > echo "${ECHO_T}$ac_header_preproc" >&6
14034 >
14035 > # So?  What about this header?
14036 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
14037 >  yes:no: )
14038 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&5
14039 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
14040 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&5
14041 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&2;}
14042 >    ac_header_preproc=yes
14043 >    ;;
14044 >  no:yes:* )
14045 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&5
14046 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&2;}
14047 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&5
14048 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&2;}
14049 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&5
14050 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&2;}
14051 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&5
14052 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&2;}
14053 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&5
14054 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&2;}
14055 >    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&5
14056 > echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&2;}
14057 >    (
14058 >      cat <<\_ASBOX
14059 > ## ------------------------------ ##
14060 > ## Report this to gezelter@nd.edu ##
14061 > ## ------------------------------ ##
14062 > _ASBOX
14063 >    ) |
14064 >      sed "s/^/$as_me: WARNING:     /" >&2
14065 >    ;;
14066 > esac
14067 > echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
14068 > echo $ECHO_N "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... $ECHO_C" >&6
14069 > if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
14070 >  echo $ECHO_N "(cached) $ECHO_C" >&6
14071 > else
14072 >  ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h=$ac_header_preproc
14073 > fi
14074 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
14075 > echo "${ECHO_T}$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6
14076 >
14077 > fi
14078 > if test $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h = yes; then
14079 >  cgal_have_header=yes
14080 > else
14081 >  cgal_have_header=no
14082 > fi
14083 >
14084 >
14085 >        if test "$cgal_have_header" == yes; then
14086 >                echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
14087 > echo $ECHO_N "checking for main in -lCGAL... $ECHO_C" >&6
14088 > if test "${ac_cv_lib_CGAL_main+set}" = set; then
14089 >  echo $ECHO_N "(cached) $ECHO_C" >&6
14090 > else
14091 >  ac_check_lib_save_LIBS=$LIBS
14092 > LIBS="-lCGAL  $LIBS"
14093 > cat >conftest.$ac_ext <<_ACEOF
14094 > /* confdefs.h.  */
14095 > _ACEOF
14096 > cat confdefs.h >>conftest.$ac_ext
14097 > cat >>conftest.$ac_ext <<_ACEOF
14098 > /* end confdefs.h.  */
14099 >
14100 >
14101 > #ifdef FC_DUMMY_MAIN
14102 > #ifndef FC_DUMMY_MAIN_EQ_F77
14103 > #  ifdef __cplusplus
14104 >     extern "C"
14105 > #  endif
14106 >   int FC_DUMMY_MAIN() { return 1; }
14107 > #endif
14108 > #endif
14109 > int
14110 > main ()
14111 > {
14112 > main ();
14113 >  ;
14114 >  return 0;
14115 > }
14116 > _ACEOF
14117 > rm -f conftest.$ac_objext conftest$ac_exeext
14118 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14119 >  (eval $ac_link) 2>conftest.er1
14120 >  ac_status=$?
14121 >  grep -v '^ *+' conftest.er1 >conftest.err
14122 >  rm -f conftest.er1
14123 >  cat conftest.err >&5
14124 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14125 >  (exit $ac_status); } &&
14126 >         { ac_try='test -z "$ac_c_werror_flag"
14127 >                         || test ! -s conftest.err'
14128 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14129 >  (eval $ac_try) 2>&5
14130 >  ac_status=$?
14131 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14132 >  (exit $ac_status); }; } &&
14133 >         { ac_try='test -s conftest$ac_exeext'
14134 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14135 >  (eval $ac_try) 2>&5
14136 >  ac_status=$?
14137 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14138 >  (exit $ac_status); }; }; then
14139 >  ac_cv_lib_CGAL_main=yes
14140 > else
14141 >  echo "$as_me: failed program was:" >&5
14142 > sed 's/^/| /' conftest.$ac_ext >&5
14143 >
14144 > ac_cv_lib_CGAL_main=no
14145 > fi
14146 > rm -f conftest.err conftest.$ac_objext \
14147 >      conftest$ac_exeext conftest.$ac_ext
14148 > LIBS=$ac_check_lib_save_LIBS
14149 > fi
14150 > echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
14151 > echo "${ECHO_T}$ac_cv_lib_CGAL_main" >&6
14152 > if test $ac_cv_lib_CGAL_main = yes; then
14153 >  cgal_have_lib=yes
14154 > else
14155 >  cgal_have_lib=no
14156 > fi
14157 >
14158 >                if test "$cgal_have_lib" == no; then
14159 >                        save_LIBS="$LIBS"; LIBS="$LIBS -lgmp -lmpfr -lm"
14160 >                        echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
14161 > echo $ECHO_N "checking for main in -lCGAL... $ECHO_C" >&6
14162 > if test "${ac_cv_lib_CGAL_main+set}" = set; then
14163 >  echo $ECHO_N "(cached) $ECHO_C" >&6
14164 > else
14165 >  ac_check_lib_save_LIBS=$LIBS
14166 > LIBS="-lCGAL  $LIBS"
14167 > cat >conftest.$ac_ext <<_ACEOF
14168 > /* confdefs.h.  */
14169 > _ACEOF
14170 > cat confdefs.h >>conftest.$ac_ext
14171 > cat >>conftest.$ac_ext <<_ACEOF
14172 > /* end confdefs.h.  */
14173 >
14174 >
14175 > #ifdef FC_DUMMY_MAIN
14176 > #ifndef FC_DUMMY_MAIN_EQ_F77
14177 > #  ifdef __cplusplus
14178 >     extern "C"
14179 > #  endif
14180 >   int FC_DUMMY_MAIN() { return 1; }
14181 > #endif
14182 > #endif
14183 > int
14184 > main ()
14185 > {
14186 > main ();
14187 >  ;
14188 >  return 0;
14189 > }
14190 > _ACEOF
14191 > rm -f conftest.$ac_objext conftest$ac_exeext
14192 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14193 >  (eval $ac_link) 2>conftest.er1
14194 >  ac_status=$?
14195 >  grep -v '^ *+' conftest.er1 >conftest.err
14196 >  rm -f conftest.er1
14197 >  cat conftest.err >&5
14198 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14199 >  (exit $ac_status); } &&
14200 >         { ac_try='test -z "$ac_c_werror_flag"
14201 >                         || test ! -s conftest.err'
14202 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14203 >  (eval $ac_try) 2>&5
14204 >  ac_status=$?
14205 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14206 >  (exit $ac_status); }; } &&
14207 >         { ac_try='test -s conftest$ac_exeext'
14208    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14209    (eval $ac_try) 2>&5
14210    ac_status=$?
14211    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14212    (exit $ac_status); }; }; then
14213 <  ac_cv_lib_mpi_MPI_Init=yes
14213 >  ac_cv_lib_CGAL_main=yes
14214   else
14215    echo "$as_me: failed program was:" >&5
14216   sed 's/^/| /' conftest.$ac_ext >&5
14217  
14218 < ac_cv_lib_mpi_MPI_Init=no
14218 > ac_cv_lib_CGAL_main=no
14219   fi
14220 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
14220 > rm -f conftest.err conftest.$ac_objext \
14221 >      conftest$ac_exeext conftest.$ac_ext
14222   LIBS=$ac_check_lib_save_LIBS
14223   fi
14224 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
14225 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
14226 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
14227 <  MPI_LIB="-lmpi -llam"
14224 > echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
14225 > echo "${ECHO_T}$ac_cv_lib_CGAL_main" >&6
14226 > if test $ac_cv_lib_CGAL_main = yes; then
14227 >  CGAL_LIBS="-lCGAL -lgmp -lmpfr"
14228 >                                                  cgal_have_lib=yes
14229 > else
14230 >  cgal_have_lib=no
14231   fi
14232  
14233 < fi
14234 < $as_unset ac_cv_lib_mpich_MPI_Init
14235 < if test x = x"$MPI_LIB"; then
14236 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
14237 < echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
14238 < if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
14233 >                        LIBS="$save_LIBS"
14234 >                else
14235 >                        CGAL_LIBS="-lCGAL"
14236 >                        echo "$as_me:$LINENO: checking for main in -lmpfr" >&5
14237 > echo $ECHO_N "checking for main in -lmpfr... $ECHO_C" >&6
14238 > if test "${ac_cv_lib_mpfr_main+set}" = set; then
14239    echo $ECHO_N "(cached) $ECHO_C" >&6
14240   else
14241    ac_check_lib_save_LIBS=$LIBS
14242 < LIBS="-lmpich "-lpmpich" $LIBS"
14242 > LIBS="-lmpfr  $LIBS"
14243   cat >conftest.$ac_ext <<_ACEOF
7277 #line $LINENO "configure"
14244   /* confdefs.h.  */
14245   _ACEOF
14246   cat confdefs.h >>conftest.$ac_ext
14247   cat >>conftest.$ac_ext <<_ACEOF
14248   /* end confdefs.h.  */
14249  
14250 < /* Override any gcc2 internal prototype to avoid an error.  */
14251 < #ifdef __cplusplus
14252 < extern "C"
14250 >
14251 > #ifdef FC_DUMMY_MAIN
14252 > #ifndef FC_DUMMY_MAIN_EQ_F77
14253 > #  ifdef __cplusplus
14254 >     extern "C"
14255 > #  endif
14256 >   int FC_DUMMY_MAIN() { return 1; }
14257   #endif
14258 < /* We use char because int might match the return type of a gcc2
7289 <   builtin and then its argument prototype would still apply.  */
7290 < char MPI_Init ();
14258 > #endif
14259   int
14260   main ()
14261   {
14262 < MPI_Init ();
14262 > main ();
14263    ;
14264    return 0;
14265   }
14266   _ACEOF
14267   rm -f conftest.$ac_objext conftest$ac_exeext
14268   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14269 <  (eval $ac_link) 2>&5
14269 >  (eval $ac_link) 2>conftest.er1
14270    ac_status=$?
14271 +  grep -v '^ *+' conftest.er1 >conftest.err
14272 +  rm -f conftest.er1
14273 +  cat conftest.err >&5
14274    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14275    (exit $ac_status); } &&
14276 <         { ac_try='test -s conftest$ac_exeext'
14276 >         { ac_try='test -z "$ac_c_werror_flag"
14277 >                         || test ! -s conftest.err'
14278    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14279    (eval $ac_try) 2>&5
14280    ac_status=$?
14281    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14282 +  (exit $ac_status); }; } &&
14283 +         { ac_try='test -s conftest$ac_exeext'
14284 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14285 +  (eval $ac_try) 2>&5
14286 +  ac_status=$?
14287 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14288    (exit $ac_status); }; }; then
14289 <  ac_cv_lib_mpich_MPI_Init=yes
14289 >  ac_cv_lib_mpfr_main=yes
14290   else
14291    echo "$as_me: failed program was:" >&5
14292   sed 's/^/| /' conftest.$ac_ext >&5
14293  
14294 < ac_cv_lib_mpich_MPI_Init=no
14294 > ac_cv_lib_mpfr_main=no
14295   fi
14296 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
14296 > rm -f conftest.err conftest.$ac_objext \
14297 >      conftest$ac_exeext conftest.$ac_ext
14298   LIBS=$ac_check_lib_save_LIBS
14299   fi
14300 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
14301 < echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
14302 < if test $ac_cv_lib_mpich_MPI_Init = yes; then
14303 <  MPI_LIB="-lmpich -lpmpich"
14300 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpfr_main" >&5
14301 > echo "${ECHO_T}$ac_cv_lib_mpfr_main" >&6
14302 > if test $ac_cv_lib_mpfr_main = yes; then
14303 >  CGAL_LIBS="$CGAL_LIBS -lmpfr"
14304   fi
14305  
14306 < fi
14307 <
14308 < $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
14306 >                        echo "$as_me:$LINENO: checking for main in -lgmp" >&5
14307 > echo $ECHO_N "checking for main in -lgmp... $ECHO_C" >&6
14308 > if test "${ac_cv_lib_gmp_main+set}" = set; then
14309    echo $ECHO_N "(cached) $ECHO_C" >&6
14310   else
14311    ac_check_lib_save_LIBS=$LIBS
14312 < LIBS="-lmpi -llam -lpthread $LIBS"
14312 > LIBS="-lgmp  $LIBS"
14313   cat >conftest.$ac_ext <<_ACEOF
7339 #line $LINENO "configure"
14314   /* confdefs.h.  */
14315   _ACEOF
14316   cat confdefs.h >>conftest.$ac_ext
14317   cat >>conftest.$ac_ext <<_ACEOF
14318   /* end confdefs.h.  */
14319  
14320 < /* Override any gcc2 internal prototype to avoid an error.  */
14321 < #ifdef __cplusplus
14322 < extern "C"
14320 >
14321 > #ifdef FC_DUMMY_MAIN
14322 > #ifndef FC_DUMMY_MAIN_EQ_F77
14323 > #  ifdef __cplusplus
14324 >     extern "C"
14325 > #  endif
14326 >   int FC_DUMMY_MAIN() { return 1; }
14327   #endif
14328 < /* 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 ();
14328 > #endif
14329   int
14330   main ()
14331   {
14332 < MPI_Init ();
14332 > main ();
14333    ;
14334    return 0;
14335   }
14336   _ACEOF
14337   rm -f conftest.$ac_objext conftest$ac_exeext
14338   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14339 <  (eval $ac_link) 2>&5
14339 >  (eval $ac_link) 2>conftest.er1
14340    ac_status=$?
14341 +  grep -v '^ *+' conftest.er1 >conftest.err
14342 +  rm -f conftest.er1
14343 +  cat conftest.err >&5
14344    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14345    (exit $ac_status); } &&
14346 <         { ac_try='test -s conftest$ac_exeext'
14346 >         { ac_try='test -z "$ac_c_werror_flag"
14347 >                         || test ! -s conftest.err'
14348    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14349    (eval $ac_try) 2>&5
14350    ac_status=$?
14351    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14352 +  (exit $ac_status); }; } &&
14353 +         { ac_try='test -s conftest$ac_exeext'
14354 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14355 +  (eval $ac_try) 2>&5
14356 +  ac_status=$?
14357 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14358    (exit $ac_status); }; }; then
14359 <  ac_cv_lib_mpi_MPI_Init=yes
14359 >  ac_cv_lib_gmp_main=yes
14360   else
14361    echo "$as_me: failed program was:" >&5
14362   sed 's/^/| /' conftest.$ac_ext >&5
14363  
14364 < ac_cv_lib_mpi_MPI_Init=no
14364 > ac_cv_lib_gmp_main=no
14365   fi
14366 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
14366 > rm -f conftest.err conftest.$ac_objext \
14367 >      conftest$ac_exeext conftest.$ac_ext
14368   LIBS=$ac_check_lib_save_LIBS
14369   fi
14370 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
14371 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
14372 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
14373 <  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 <
14370 > echo "$as_me:$LINENO: result: $ac_cv_lib_gmp_main" >&5
14371 > echo "${ECHO_T}$ac_cv_lib_gmp_main" >&6
14372 > if test $ac_cv_lib_gmp_main = yes; then
14373 >  CGAL_LIBS="$CGAL_LIBS -lgmp"
14374   fi
14375  
14376 < fi
14377 <
14378 <
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
7451 < else
7452 <        echo "$as_me:$LINENO: result: no! Check SPRNG include path!" >&5
7453 < echo "${ECHO_T}no! Check SPRNG include path!" >&6
7454 <        USE_SPRNG="no"
7455 < fi
7456 < rm -f conftest*
7457 < if test "$have_sprng_h" = 1; then
7458 <
7459 < cat >>confdefs.h <<\_ACEOF
7460 < #define HAVE_SPRNG_H 1
7461 < _ACEOF
7462 <
7463 < fi
7464 <
7465 < ac_ext=c
7466 < ac_cpp='$CPP $CPPFLAGS'
7467 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7468 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7469 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
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
14376 >                        echo "$as_me:$LINENO: checking for main in -lgmpxx" >&5
14377 > echo $ECHO_N "checking for main in -lgmpxx... $ECHO_C" >&6
14378 > if test "${ac_cv_lib_gmpxx_main+set}" = set; then
14379    echo $ECHO_N "(cached) $ECHO_C" >&6
14380   else
14381    ac_check_lib_save_LIBS=$LIBS
14382 < LIBS="-lsprng  $LIBS"
14382 > LIBS="-lgmpxx  $LIBS"
14383   cat >conftest.$ac_ext <<_ACEOF
7482 #line $LINENO "configure"
14384   /* confdefs.h.  */
14385   _ACEOF
14386   cat confdefs.h >>conftest.$ac_ext
14387   cat >>conftest.$ac_ext <<_ACEOF
14388   /* end confdefs.h.  */
14389  
14390 < /* Override any gcc2 internal prototype to avoid an error.  */
14391 < #ifdef __cplusplus
14392 < extern "C"
14390 >
14391 > #ifdef FC_DUMMY_MAIN
14392 > #ifndef FC_DUMMY_MAIN_EQ_F77
14393 > #  ifdef __cplusplus
14394 >     extern "C"
14395 > #  endif
14396 >   int FC_DUMMY_MAIN() { return 1; }
14397   #endif
14398 < /* We use char because int might match the return type of a gcc2
7494 <   builtin and then its argument prototype would still apply.  */
7495 < char init_rng ();
14398 > #endif
14399   int
14400   main ()
14401   {
14402 < init_rng ();
14402 > main ();
14403    ;
14404    return 0;
14405   }
14406   _ACEOF
14407   rm -f conftest.$ac_objext conftest$ac_exeext
14408   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14409 <  (eval $ac_link) 2>&5
14409 >  (eval $ac_link) 2>conftest.er1
14410    ac_status=$?
14411 +  grep -v '^ *+' conftest.er1 >conftest.err
14412 +  rm -f conftest.er1
14413 +  cat conftest.err >&5
14414    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14415    (exit $ac_status); } &&
14416 <         { ac_try='test -s conftest$ac_exeext'
14417 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14416 >         { ac_try='test -z "$ac_c_werror_flag"
14417 >                         || test ! -s conftest.err'
14418 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14419    (eval $ac_try) 2>&5
14420    ac_status=$?
14421    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14422 <  (exit $ac_status); }; }; then
14423 <  ac_cv_lib_sprng_init_rng=yes
7517 < else
7518 <  echo "$as_me: failed program was:" >&5
7519 < sed 's/^/| /' conftest.$ac_ext >&5
7520 <
7521 < ac_cv_lib_sprng_init_rng=no
7522 < fi
7523 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
7524 < LIBS=$ac_check_lib_save_LIBS
7525 < fi
7526 < echo "$as_me:$LINENO: result: $ac_cv_lib_sprng_init_rng" >&5
7527 < echo "${ECHO_T}$ac_cv_lib_sprng_init_rng" >&6
7528 < if test $ac_cv_lib_sprng_init_rng = yes; then
7529 <  SPRNG_LIB="-lsprng"
7530 < else
7531 <
7532 <             { { echo "$as_me:$LINENO: error: Didn't find libsprng; check path for SPRNG package first..." >&5
7533 < echo "$as_me: error: Didn't find libsprng; check path for SPRNG package first..." >&2;}
7534 <   { (exit 1); exit 1; }; }
7535 <             USE_SPRNG="no"
7536 <
7537 < fi
7538 <
7539 <
7540 < if test "$USE_SPRNG" = "no"; then
7541 <  { { echo "$as_me:$LINENO: error: No working SPRNG library found" >&5
7542 < echo "$as_me: error: No working SPRNG library found" >&2;}
7543 <   { (exit 1); exit 1; }; }
7544 < fi
7545 <
7546 <
7547 < fi
7548 <
7549 <
7550 <
7551 < echo "$as_me:$LINENO: checking if MKL is wanted" >&5
7552 < echo $ECHO_N "checking if MKL is wanted... $ECHO_C" >&6
7553 <
7554 < # Check whether --with-mkl or --without-mkl was given.
7555 < if test "${with_mkl+set}" = set; then
7556 <  withval="$with_mkl"
7557 <     echo "$as_me:$LINENO: result: yes" >&5
7558 < echo "${ECHO_T}yes" >&6
7559 <    for dir in $withval /usr/local/intel/mkl61 /opt/intel/mkl61; do
7560 <        mkldir="$dir"
7561 <        if test -f "$dir/include/mkl.h"; then
7562 <            found_mkl="yes";
7563 <            break;
7564 <        fi
7565 <    done
7566 <    if test x_$found_mkl != x_yes; then
7567 <        { { echo "$as_me:$LINENO: error: Cannot find MKL includes" >&5
7568 < echo "$as_me: error: Cannot find MKL includes" >&2;}
7569 <   { (exit 1); exit 1; }; }
7570 <    else
7571 <        printf "MKL includes found in $mkldir/include\n";
7572 <    fi
7573 <
7574 <
7575 <
7576 <  ac_ext=c
7577 < ac_cpp='$CPP $CPPFLAGS'
7578 < 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
7581 <
7582 <  ac_save_CPPFLAGS=$CPPFLAGS
7583 <  CPPFLAGS="${CPPFLAGS} -I${mkldir}/include"
7584 <  ac_save_LDFLAGS=$LDFLAGS
7585 <  LDFLAGS="${LDFLAGS} -L${mkldir}/lib/32 -lmkl -lvml -lguide"
7586 <  if test "${ac_cv_header_mkl_h+set}" = set; then
7587 <  echo "$as_me:$LINENO: checking for mkl.h" >&5
7588 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
7589 < if test "${ac_cv_header_mkl_h+set}" = set; then
7590 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7591 < fi
7592 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
7593 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
7594 < else
7595 <  # Is the header compilable?
7596 < echo "$as_me:$LINENO: checking mkl.h usability" >&5
7597 < echo $ECHO_N "checking mkl.h usability... $ECHO_C" >&6
7598 < cat >conftest.$ac_ext <<_ACEOF
7599 < #line $LINENO "configure"
7600 < /* confdefs.h.  */
7601 < _ACEOF
7602 < cat confdefs.h >>conftest.$ac_ext
7603 < cat >>conftest.$ac_ext <<_ACEOF
7604 < /* end confdefs.h.  */
7605 < $ac_includes_default
7606 < #include <mkl.h>
7607 < _ACEOF
7608 < rm -f conftest.$ac_objext
7609 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7610 <  (eval $ac_compile) 2>&5
7611 <  ac_status=$?
7612 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7613 <  (exit $ac_status); } &&
7614 <         { ac_try='test -s conftest.$ac_objext'
14422 >  (exit $ac_status); }; } &&
14423 >         { ac_try='test -s conftest$ac_exeext'
14424    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14425    (eval $ac_try) 2>&5
14426    ac_status=$?
14427    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14428    (exit $ac_status); }; }; then
14429 <  ac_header_compiler=yes
14429 >  ac_cv_lib_gmpxx_main=yes
14430   else
14431    echo "$as_me: failed program was:" >&5
14432   sed 's/^/| /' conftest.$ac_ext >&5
14433  
14434 < ac_header_compiler=no
14434 > ac_cv_lib_gmpxx_main=no
14435   fi
14436 < rm -f conftest.$ac_objext conftest.$ac_ext
14437 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
14438 < echo "${ECHO_T}$ac_header_compiler" >&6
7630 <
7631 < # Is the header present?
7632 < echo "$as_me:$LINENO: checking mkl.h presence" >&5
7633 < echo $ECHO_N "checking mkl.h presence... $ECHO_C" >&6
7634 < cat >conftest.$ac_ext <<_ACEOF
7635 < #line $LINENO "configure"
7636 < /* confdefs.h.  */
7637 < _ACEOF
7638 < cat confdefs.h >>conftest.$ac_ext
7639 < cat >>conftest.$ac_ext <<_ACEOF
7640 < /* end confdefs.h.  */
7641 < #include <mkl.h>
7642 < _ACEOF
7643 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7644 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7645 <  ac_status=$?
7646 <  grep -v '^ *+' conftest.er1 >conftest.err
7647 <  rm -f conftest.er1
7648 <  cat conftest.err >&5
7649 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7650 <  (exit $ac_status); } >/dev/null; then
7651 <  if test -s conftest.err; then
7652 <    ac_cpp_err=$ac_c_preproc_warn_flag
7653 <  else
7654 <    ac_cpp_err=
7655 <  fi
7656 < else
7657 <  ac_cpp_err=yes
14436 > rm -f conftest.err conftest.$ac_objext \
14437 >      conftest$ac_exeext conftest.$ac_ext
14438 > LIBS=$ac_check_lib_save_LIBS
14439   fi
14440 < if test -z "$ac_cpp_err"; then
14441 <  ac_header_preproc=yes
14442 < else
14443 <  echo "$as_me: failed program was:" >&5
7663 < sed 's/^/| /' conftest.$ac_ext >&5
7664 <
7665 <  ac_header_preproc=no
14440 > echo "$as_me:$LINENO: result: $ac_cv_lib_gmpxx_main" >&5
14441 > echo "${ECHO_T}$ac_cv_lib_gmpxx_main" >&6
14442 > if test $ac_cv_lib_gmpxx_main = yes; then
14443 >  CGAL_LIBS="$CGAL_LIBS -lgmpxx"
14444   fi
7667 rm -f conftest.err conftest.$ac_ext
7668 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7669 echo "${ECHO_T}$ac_header_preproc" >&6
14445  
14446 < # So?  What about this header?
7672 < case $ac_header_compiler:$ac_header_preproc in
7673 <  yes:no )
7674 <    { echo "$as_me:$LINENO: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&5
7675 < echo "$as_me: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
7676 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the preprocessor's result" >&5
7677 < echo "$as_me: WARNING: mkl.h: proceeding with the preprocessor's result" >&2;}
7678 <    (
7679 <      cat <<\_ASBOX
7680 < ## ------------------------------------ ##
7681 < ## Report this to bug-autoconf@gnu.org. ##
7682 < ## ------------------------------------ ##
7683 < _ASBOX
7684 <    ) |
7685 <      sed "s/^/$as_me: WARNING:     /" >&2
7686 <    ;;
7687 <  no:yes )
7688 <    { echo "$as_me:$LINENO: WARNING: mkl.h: present but cannot be compiled" >&5
7689 < echo "$as_me: WARNING: mkl.h: present but cannot be compiled" >&2;}
7690 <    { echo "$as_me:$LINENO: WARNING: mkl.h: check for missing prerequisite headers?" >&5
7691 < echo "$as_me: WARNING: mkl.h: check for missing prerequisite headers?" >&2;}
7692 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the preprocessor's result" >&5
7693 < echo "$as_me: WARNING: mkl.h: proceeding with the preprocessor's result" >&2;}
7694 <    (
7695 <      cat <<\_ASBOX
7696 < ## ------------------------------------ ##
7697 < ## Report this to bug-autoconf@gnu.org. ##
7698 < ## ------------------------------------ ##
7699 < _ASBOX
7700 <    ) |
7701 <      sed "s/^/$as_me: WARNING:     /" >&2
7702 <    ;;
7703 < esac
7704 < echo "$as_me:$LINENO: checking for mkl.h" >&5
7705 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
7706 < if test "${ac_cv_header_mkl_h+set}" = set; then
7707 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7708 < else
7709 <  ac_cv_header_mkl_h=$ac_header_preproc
7710 < fi
7711 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
7712 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
14446 >                fi
14447  
14448 < fi
14449 < if test $ac_cv_header_mkl_h = yes; then
14450 <
14451 <    echo "$as_me:$LINENO: checking for vslNewStream in -lmkl" >&5
14452 < echo $ECHO_N "checking for vslNewStream in -lmkl... $ECHO_C" >&6
14453 < if test "${ac_cv_lib_mkl_vslNewStream+set}" = set; then
14448 >                if test "$cgal_have_lib" == yes; then
14449 >                        acx_cgal_found=yes
14450 >                fi
14451 >        fi
14452 >        if test "$acx_cgal_found" == yes; then
14453 >                echo "$as_me:$LINENO: checking for main in -lCore" >&5
14454 > echo $ECHO_N "checking for main in -lCore... $ECHO_C" >&6
14455 > if test "${ac_cv_lib_Core_main+set}" = set; then
14456    echo $ECHO_N "(cached) $ECHO_C" >&6
14457   else
14458    ac_check_lib_save_LIBS=$LIBS
14459 < LIBS="-lmkl  $LIBS"
14459 > LIBS="-lCore  $LIBS"
14460   cat >conftest.$ac_ext <<_ACEOF
7725 #line $LINENO "configure"
14461   /* confdefs.h.  */
14462   _ACEOF
14463   cat confdefs.h >>conftest.$ac_ext
14464   cat >>conftest.$ac_ext <<_ACEOF
14465   /* end confdefs.h.  */
14466  
14467 < /* Override any gcc2 internal prototype to avoid an error.  */
14468 < #ifdef __cplusplus
14469 < extern "C"
14467 >
14468 > #ifdef FC_DUMMY_MAIN
14469 > #ifndef FC_DUMMY_MAIN_EQ_F77
14470 > #  ifdef __cplusplus
14471 >     extern "C"
14472 > #  endif
14473 >   int FC_DUMMY_MAIN() { return 1; }
14474   #endif
14475 < /* 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 ();
14475 > #endif
14476   int
14477   main ()
14478   {
14479 < vslNewStream ();
14479 > main ();
14480    ;
14481    return 0;
14482   }
14483   _ACEOF
14484   rm -f conftest.$ac_objext conftest$ac_exeext
14485   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
14486 <  (eval $ac_link) 2>&5
14486 >  (eval $ac_link) 2>conftest.er1
14487    ac_status=$?
14488 +  grep -v '^ *+' conftest.er1 >conftest.err
14489 +  rm -f conftest.er1
14490 +  cat conftest.err >&5
14491    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14492    (exit $ac_status); } &&
14493 <         { ac_try='test -s conftest$ac_exeext'
14493 >         { ac_try='test -z "$ac_c_werror_flag"
14494 >                         || test ! -s conftest.err'
14495    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14496    (eval $ac_try) 2>&5
14497    ac_status=$?
14498    echo "$as_me:$LINENO: \$? = $ac_status" >&5
14499 +  (exit $ac_status); }; } &&
14500 +         { ac_try='test -s conftest$ac_exeext'
14501 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
14502 +  (eval $ac_try) 2>&5
14503 +  ac_status=$?
14504 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
14505    (exit $ac_status); }; }; then
14506 <  ac_cv_lib_mkl_vslNewStream=yes
14506 >  ac_cv_lib_Core_main=yes
14507   else
14508    echo "$as_me: failed program was:" >&5
14509   sed 's/^/| /' conftest.$ac_ext >&5
14510  
14511 < ac_cv_lib_mkl_vslNewStream=no
14511 > ac_cv_lib_Core_main=no
14512   fi
14513 < rm -f conftest.$ac_objext conftest$ac_exeext conftest.$ac_ext
14513 > rm -f conftest.err conftest.$ac_objext \
14514 >      conftest$ac_exeext conftest.$ac_ext
14515   LIBS=$ac_check_lib_save_LIBS
14516   fi
14517 < echo "$as_me:$LINENO: result: $ac_cv_lib_mkl_vslNewStream" >&5
14518 < echo "${ECHO_T}$ac_cv_lib_mkl_vslNewStream" >&6
14519 < if test $ac_cv_lib_mkl_vslNewStream = yes; then
14520 <  MKL_LIBDIR="${mkldir}/lib/32",
7773 <                     MKL_LIB="-lmkl -lvml -lguide",
7774 <                     HAVE_MKL="yes"
14517 > echo "$as_me:$LINENO: result: $ac_cv_lib_Core_main" >&5
14518 > echo "${ECHO_T}$ac_cv_lib_Core_main" >&6
14519 > if test $ac_cv_lib_Core_main = yes; then
14520 >  CGAL_LIBS="$CGAL_LIBS -lCore"
14521   fi
14522  
14523 <
7778 < else
7779 <  MKL_INC="-I${mkldir}/include"
14523 >        fi
14524   fi
14525  
14526  
7783  CPPFLAGS=$ac_save_CPPFLAGS
7784  LDFLAGS=$ac_save_LDFLAGS
7785  ac_ext=c
7786 ac_cpp='$CPP $CPPFLAGS'
7787 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7788 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7789 ac_compiler_gnu=$ac_cv_c_compiler_gnu
14527  
14528 + echo "$as_me:$LINENO: checking CGAL" >&5
14529 + echo $ECHO_N "checking CGAL... $ECHO_C" >&6
14530 + if test "$acx_cgal_found" == yes; then
14531 +        echo "$as_me:$LINENO: result: yes" >&5
14532 + echo "${ECHO_T}yes" >&6;
14533  
14534 <  if test x_$HAVE_MKL != x_yes; then
14535 <        { { echo "$as_me:$LINENO: error: Can't build with MKL" >&5
14536 < echo "$as_me: error: Can't build with MKL" >&2;}
7795 <   { (exit 1); exit 1; }; }
7796 <  fi
14534 > else
14535 >        echo "$as_me:$LINENO: result: no" >&5
14536 > echo "${ECHO_T}no" >&6
14537  
14538 + fi
14539 + USE_CGAL=no
14540 + if test "$acx_cgal_found" == yes; then
14541 +        USE_CGAL=yes
14542  
14543 + cat >>confdefs.h <<\_ACEOF
14544 + #define HAVE_CGAL 1
14545 + _ACEOF
14546  
14547  
14548  
7802 else
14549  
7804    echo "$as_me:$LINENO: result: no" >&5
7805 echo "${ECHO_T}no" >&6
14550  
14551 < fi;
14551 > fi
14552  
14553  
14554  
14555 +
14556   # Check whether --enable-doxygen or --disable-doxygen was given.
14557   if test "${enable_doxygen+set}" = set; then
14558    enableval="$enable_doxygen"
# Line 7949 | Line 14694 | fi
14694  
14695  
14696  
7952 OBJEXT=".$OBJEXT"
14697  
7954 OOPSE=oopse
14698  
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;
14699  
7968 case "x$INSTALL" in
7969   x/*) ;;
7970   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
7971 esac
14700  
7973 MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
14701  
7975 CFLAGS=${CFLAGS-""}
7976 CXXFLAGS=${CXXFLAGS-""}
7977 CPPFLAGS=${CPPFLAGS-""}
7978 FFLAGS=${FFLAGS-""}
7979 F90FLAGS=${F90FLAGS-""}
7980 LDFLAGS=${LDFLAGS-""}
7981 DEBUG=${DEBUG-"-g"}
14702  
7983 case $debug in
7984  1)
7985     FFLAGS="$DEBUG $FFLAGS"
7986     F90FLAGS="$DEBUG $F90FLAGS"
7987     ;;
7988  *)
7989     ;;
7990 esac
14703  
14704  
14705  
14706  
14707  
14708  
14709 <
7998 <
7999 <
8000 <
8001 <
8002 <
8003 <
8004 <
8005 <
8006 <
8007 <
14709 >                                        ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/math/Makefile scripts/filepp"
14710  
8009          ac_config_headers="$ac_config_headers src/config.h"
14711  
8011                    ac_config_files="$ac_config_files make/Makefile src/utils/Makefile"
8012
8013
14712   cat >confcache <<\_ACEOF
14713   # This file is a shell script that caches the results of configure
14714   # tests run on this system so they can be shared between configure
# Line 8039 | Line 14737 | _ACEOF
14737        # `set' does not quote correctly, so add quotes (double-quote
14738        # substitution turns \\\\ into \\, and sed turns \\ into \).
14739        sed -n \
14740 <        "s/'/'\\\\''/g;
14741 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
14740 >        "s/'/'\\\\''/g;
14741 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
14742        ;;
14743      *)
14744        # `set' quotes correctly as required by POSIX, so do not add quotes.
14745        sed -n \
14746 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
14746 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
14747        ;;
14748      esac;
14749   } |
# Line 8075 | Line 14773 | if test "x$srcdir" = x.; then
14773   # trailing colons and then remove the whole line if VPATH becomes empty
14774   # (actually we leave an empty line to preserve line numbers).
14775   if test "x$srcdir" = x.; then
14776 <  ac_vpsub='/^[         ]*VPATH[        ]*=/{
14776 >  ac_vpsub='/^[  ]*VPATH[        ]*=/{
14777   s/:*\$(srcdir):*/:/;
14778   s/:*\${srcdir}:*/:/;
14779   s/:*@srcdir@:*/:/;
14780 < s/^\([^=]*=[    ]*\):*/\1/;
14780 > s/^\([^=]*=[     ]*\):*/\1/;
14781   s/:*$//;
14782 < s/^[^=]*=[      ]*$//;
14782 > s/^[^=]*=[       ]*$//;
14783   }'
14784   fi
14785  
# Line 8092 | Line 14790 | for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && conti
14790   for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
14791    # 1. Remove the extension, and $U if already installed.
14792    ac_i=`echo "$ac_i" |
14793 <         sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
14793 >         sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
14794    # 2. Add them.
14795    ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
14796    ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
# Line 8136 | Line 14834 | fi
14834   elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
14835    set -o posix
14836   fi
14837 + DUALCASE=1; export DUALCASE # for MKS sh
14838  
14839   # Support unset when possible.
14840 < if (FOO=FOO; unset FOO) >/dev/null 2>&1; then
14840 > if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
14841    as_unset=unset
14842   else
14843    as_unset=false
# Line 8157 | Line 14856 | do
14856    LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
14857    LC_TELEPHONE LC_TIME
14858   do
14859 <  if (set +x; test -n "`(eval $as_var=C; export $as_var) 2>&1`"); then
14859 >  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
14860      eval $as_var=C; export $as_var
14861    else
14862      $as_unset $as_var
# Line 8336 | Line 15035 | else
15035   if mkdir -p . 2>/dev/null; then
15036    as_mkdir_p=:
15037   else
15038 +  test -d ./-p && rmdir ./-p
15039    as_mkdir_p=false
15040   fi
15041  
15042   as_executable_p="test -f"
15043  
15044   # Sed expression to map a string onto a valid CPP name.
15045 < as_tr_cpp="sed y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
15045 > as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
15046  
15047   # Sed expression to map a string onto a valid variable name.
15048 < as_tr_sh="sed y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
15048 > as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
15049  
15050  
15051   # IFS
# Line 8371 | Line 15071 | cat >&5 <<_CSEOF
15071   } >&5
15072   cat >&5 <<_CSEOF
15073  
15074 < This file was extended by OOPSE $as_me 2.0, which was
15075 < generated by GNU Autoconf 2.57.  Invocation command line was
15074 > This file was extended by OOPSE $as_me 4.0, which was
15075 > generated by GNU Autoconf 2.59.  Invocation command line was
15076  
15077    CONFIG_FILES    = $CONFIG_FILES
15078    CONFIG_HEADERS  = $CONFIG_HEADERS
# Line 8416 | Line 15116 | Usage: $0 [OPTIONS] [FILE]...
15116    -d, --debug      don't remove temporary files
15117        --recheck    update $as_me by reconfiguring in the same conditions
15118    --file=FILE[:TEMPLATE]
15119 <                   instantiate the configuration file FILE
15119 >                   instantiate the configuration file FILE
15120    --header=FILE[:TEMPLATE]
15121 <                   instantiate the configuration header FILE
15121 >                   instantiate the configuration header FILE
15122  
15123   Configuration files:
15124   $config_files
# Line 8434 | Line 15134 | ac_cs_version="\\
15134  
15135   cat >>$CONFIG_STATUS <<_ACEOF
15136   ac_cs_version="\\
15137 < OOPSE config.status 2.0
15138 < configured by $0, generated by GNU Autoconf 2.57,
15137 > OOPSE config.status 4.0
15138 > configured by $0, generated by GNU Autoconf 2.59,
15139    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
15140  
15141 < Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
8442 < Free Software Foundation, Inc.
15141 > Copyright (C) 2003 Free Software Foundation, Inc.
15142   This config.status script is free software; the Free Software Foundation
15143   gives unlimited permission to copy, distribute and modify it."
15144   srcdir=$srcdir
# Line 8540 | Line 15239 | do
15239    # Handling of arguments.
15240    "make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
15241    "src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
15242 +  "src/math/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/math/Makefile" ;;
15243 +  "scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
15244    "src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
15245    "src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
15246    *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
# Line 8627 | Line 15328 | s,@LIBS@,$LIBS,;t t
15328   s,@ECHO_N@,$ECHO_N,;t t
15329   s,@ECHO_T@,$ECHO_T,;t t
15330   s,@LIBS@,$LIBS,;t t
8630 s,@PROGNAME@,$PROGNAME,;t t
8631 s,@debug@,$debug,;t t
15331   s,@build@,$build,;t t
15332   s,@build_cpu@,$build_cpu,;t t
15333   s,@build_vendor@,$build_vendor,;t t
# Line 8637 | Line 15336 | s,@host_os@,$host_os,;t t
15336   s,@host_cpu@,$host_cpu,;t t
15337   s,@host_vendor@,$host_vendor,;t t
15338   s,@host_os@,$host_os,;t t
15339 < s,@CC@,$CC,;t t
15340 < s,@CFLAGS@,$CFLAGS,;t t
15339 > s,@PROGNAME@,$PROGNAME,;t t
15340 > s,@debug@,$debug,;t t
15341 > s,@USE_SINGLE_PRECISION@,$USE_SINGLE_PRECISION,;t t
15342 > s,@CXX@,$CXX,;t t
15343 > s,@CXXFLAGS@,$CXXFLAGS,;t t
15344   s,@LDFLAGS@,$LDFLAGS,;t t
15345   s,@CPPFLAGS@,$CPPFLAGS,;t t
15346 < s,@ac_ct_CC@,$ac_ct_CC,;t t
15346 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15347   s,@EXEEXT@,$EXEEXT,;t t
15348   s,@OBJEXT@,$OBJEXT,;t t
15349 < s,@CXX@,$CXX,;t t
15350 < s,@CXXFLAGS@,$CXXFLAGS,;t t
15351 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
15352 < s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
15353 < s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
15354 < 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
15349 > s,@CC@,$CC,;t t
15350 > s,@CFLAGS@,$CFLAGS,;t t
15351 > s,@ac_ct_CC@,$ac_ct_CC,;t t
15352 > s,@FC@,$FC,;t t
15353 > s,@FCFLAGS@,$FCFLAGS,;t t
15354 > s,@ac_ct_FC@,$ac_ct_FC,;t t
15355   s,@CPP@,$CPP,;t t
15356   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
15357   s,@LN_S@,$LN_S,;t t
15358   s,@SET_MAKE@,$SET_MAKE,;t t
15359   s,@RANLIB@,$RANLIB,;t t
15360   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
15361 < s,@YACC@,$YACC,;t t
15362 < s,@LEX@,$LEX,;t t
15363 < s,@LEXLIB@,$LEXLIB,;t t
15364 < s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
15361 > s,@PERLINTERP@,$PERLINTERP,;t t
15362 > s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
15363 > s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
15364 > s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
15365 > s,@INSTALL_DATA@,$INSTALL_DATA,;t t
15366   s,@AR@,$AR,;t t
15367   s,@PS@,$PS,;t t
15368 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
15369 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
15370 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
15371 + s,@FCLIBS@,$FCLIBS,;t t
15372 + s,@FC_FUNC@,$FC_FUNC,;t t
15373 + s,@FC_FUNC_@,$FC_FUNC_,;t t
15374 + s,@MOD@,$MOD,;t t
15375 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
15376 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
15377 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
15378 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
15379 + s,@ZLIB_INC_DIR@,$ZLIB_INC_DIR,;t t
15380 + s,@ZLIB_LIB_DIR@,$ZLIB_LIB_DIR,;t t
15381 + s,@ZLIB@,$ZLIB,;t t
15382 + s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
15383 + s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
15384 + s,@FFTW_LIBS@,$FFTW_LIBS,;t t
15385 + s,@QHULL_INC_DIR@,$QHULL_INC_DIR,;t t
15386 + s,@QHULL_LIB_DIR@,$QHULL_LIB_DIR,;t t
15387 + s,@QHULL@,$QHULL,;t t
15388 + s,@USE_QHULL@,$USE_QHULL,;t t
15389 + s,@LIBOBJS@,$LIBOBJS,;t t
15390 + s,@POW_LIB@,$POW_LIB,;t t
15391 + s,@CXXCPP@,$CXXCPP,;t t
15392 + s,@__func__@,$__func__,;t t
15393   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
15394   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
15395   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
15396   s,@MPI_LIB@,$MPI_LIB,;t t
15397   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
15398   s,@USE_MPI@,$USE_MPI,;t t
15399 < s,@SPRNG_LIB_DIR@,$SPRNG_LIB_DIR,;t t
15400 < s,@SPRNG_INC_DIR@,$SPRNG_INC_DIR,;t t
15401 < s,@SPRNG_LIB@,$SPRNG_LIB,;t t
15402 < s,@USE_SPRNG@,$USE_SPRNG,;t t
15403 < s,@MKL_LIBDIR@,$MKL_LIBDIR,;t t
8692 < s,@MKL_LIB@,$MKL_LIB,;t t
8693 < s,@MKL_INC@,$MKL_INC,;t t
8694 < s,@HAVE_MKL@,$HAVE_MKL,;t t
15399 > s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
15400 > s,@CGAL_LDFLAGS@,$CGAL_LDFLAGS,;t t
15401 > s,@CGAL_CPPFLAGS@,$CGAL_CPPFLAGS,;t t
15402 > s,@CGAL_LIBS@,$CGAL_LIBS,;t t
15403 > s,@USE_CGAL@,$USE_CGAL,;t t
15404   s,@DOXYGEN@,$DOXYGEN,;t t
15405   s,@DOT@,$DOT,;t t
15406   s,@DOC@,$DOC,;t t
# Line 8703 | Line 15412 | s,@SUBDIRS@,$SUBDIRS,;t t
15412   s,@OOPSE@,$OOPSE,;t t
15413   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
15414   s,@SUBDIRS@,$SUBDIRS,;t t
8706 s,@FFLAGS@,$FFLAGS,;t t
15415   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
15416   CEOF
15417  
# Line 8734 | Line 15442 | _ACEOF
15442        (echo ':t
15443    /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
15444        if test -z "$ac_sed_cmds"; then
15445 <        ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
15445 >        ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
15446        else
15447 <        ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
15447 >        ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
15448        fi
15449        ac_sed_frag=`expr $ac_sed_frag + 1`
15450        ac_beg=$ac_end
# Line 8754 | Line 15462 | for ac_file in : $CONFIG_FILES; do test "x$ac_file" =
15462    # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
15463    case $ac_file in
15464    - | *:- | *:-:* ) # input from stdin
15465 <        cat >$tmp/stdin
15466 <        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15467 <        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15465 >        cat >$tmp/stdin
15466 >        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15467 >        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15468    *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15469 <        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15469 >        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15470    * )   ac_file_in=$ac_file.in ;;
15471    esac
15472  
15473    # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
15474    ac_dir=`(dirname "$ac_file") 2>/dev/null ||
15475   $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15476 <         X"$ac_file" : 'X\(//\)[^/]' \| \
15477 <         X"$ac_file" : 'X\(//\)$' \| \
15478 <         X"$ac_file" : 'X\(/\)' \| \
15479 <         .     : '\(.\)' 2>/dev/null ||
15476 >         X"$ac_file" : 'X\(//\)[^/]' \| \
15477 >         X"$ac_file" : 'X\(//\)$' \| \
15478 >         X"$ac_file" : 'X\(/\)' \| \
15479 >         .     : '\(.\)' 2>/dev/null ||
15480   echo X"$ac_file" |
15481      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15482            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 8784 | Line 15492 | $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
15492        as_dirs="$as_dir $as_dirs"
15493        as_dir=`(dirname "$as_dir") 2>/dev/null ||
15494   $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15495 <         X"$as_dir" : 'X\(//\)[^/]' \| \
15496 <         X"$as_dir" : 'X\(//\)$' \| \
15497 <         X"$as_dir" : 'X\(/\)' \| \
15498 <         .     : '\(.\)' 2>/dev/null ||
15495 >         X"$as_dir" : 'X\(//\)[^/]' \| \
15496 >         X"$as_dir" : 'X\(//\)$' \| \
15497 >         X"$as_dir" : 'X\(/\)' \| \
15498 >         .     : '\(.\)' 2>/dev/null ||
15499   echo X"$as_dir" |
15500      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15501            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 8825 | Line 15533 | esac
15533      ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
15534      ac_top_srcdir=$ac_top_builddir$srcdir ;;
15535   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`
15536  
15537 + # Do not use `cd foo && pwd` to compute absolute paths, because
15538 + # the directories may not exist.
15539 + case `pwd` in
15540 + .) ac_abs_builddir="$ac_dir";;
15541 + *)
15542 +  case "$ac_dir" in
15543 +  .) ac_abs_builddir=`pwd`;;
15544 +  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
15545 +  *) ac_abs_builddir=`pwd`/"$ac_dir";;
15546 +  esac;;
15547 + esac
15548 + case $ac_abs_builddir in
15549 + .) ac_abs_top_builddir=${ac_top_builddir}.;;
15550 + *)
15551 +  case ${ac_top_builddir}. in
15552 +  .) ac_abs_top_builddir=$ac_abs_builddir;;
15553 +  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
15554 +  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
15555 +  esac;;
15556 + esac
15557 + case $ac_abs_builddir in
15558 + .) ac_abs_srcdir=$ac_srcdir;;
15559 + *)
15560 +  case $ac_srcdir in
15561 +  .) ac_abs_srcdir=$ac_abs_builddir;;
15562 +  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
15563 +  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
15564 +  esac;;
15565 + esac
15566 + case $ac_abs_builddir in
15567 + .) ac_abs_top_srcdir=$ac_top_srcdir;;
15568 + *)
15569 +  case $ac_top_srcdir in
15570 +  .) ac_abs_top_srcdir=$ac_abs_builddir;;
15571 +  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
15572 +  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
15573 +  esac;;
15574 + esac
15575  
15576 +
15577    case $INSTALL in
15578    [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
15579    *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
# Line 8852 | Line 15593 | echo "$as_me: creating $ac_file" >&6;}
15593      configure_input="$ac_file.  "
15594    fi
15595    configure_input=$configure_input"Generated from `echo $ac_file_in |
15596 <                                     sed 's,.*/,,'` by configure."
15596 >                                     sed 's,.*/,,'` by configure."
15597  
15598    # First look for the input files in the build tree, otherwise in the
15599    # src tree.
# Line 8861 | Line 15602 | echo "$as_me: creating $ac_file" >&6;}
15602        case $f in
15603        -) echo $tmp/stdin ;;
15604        [\\/$]*)
15605 <         # Absolute (can't be DOS-style, as IFS=:)
15606 <         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15605 >         # Absolute (can't be DOS-style, as IFS=:)
15606 >         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15607   echo "$as_me: error: cannot find input file: $f" >&2;}
15608     { (exit 1); exit 1; }; }
15609 <         echo $f;;
15609 >         echo "$f";;
15610        *) # Relative
15611 <         if test -f "$f"; then
15612 <           # Build tree
15613 <           echo $f
15614 <         elif test -f "$srcdir/$f"; then
15615 <           # Source tree
15616 <           echo $srcdir/$f
15617 <         else
15618 <           # /dev/null tree
15619 <           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15611 >         if test -f "$f"; then
15612 >           # Build tree
15613 >           echo "$f"
15614 >         elif test -f "$srcdir/$f"; then
15615 >           # Source tree
15616 >           echo "$srcdir/$f"
15617 >         else
15618 >           # /dev/null tree
15619 >           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15620   echo "$as_me: error: cannot find input file: $f" >&2;}
15621     { (exit 1); exit 1; }; }
15622 <         fi;;
15622 >         fi;;
15623        esac
15624      done` || { (exit 1); exit 1; }
15625   _ACEOF
# Line 8908 | Line 15649 | s,@INSTALL@,$ac_INSTALL,;t t
15649      rm -f $tmp/out
15650    fi
15651  
15652 +  # Run the commands associated with the file.
15653 +  case $ac_file in
15654 +    make/Makefile ) chmod 0755 scripts/* ;;
15655 +    src/utils/Makefile ) chmod 0755 scripts/* ;;
15656 +    src/math/Makefile ) chmod 0755 scripts/* ;;
15657 +    scripts/filepp ) chmod 0755 scripts/* ;;
15658 +  esac
15659   done
15660   _ACEOF
15661   cat >>$CONFIG_STATUS <<\_ACEOF
# Line 8920 | Line 15668 | cat >>$CONFIG_STATUS <<\_ACEOF
15668   # NAME is the cpp macro being defined and VALUE is the value it is being given.
15669   #
15670   # ac_d sets the value in "#define NAME VALUE" lines.
15671 < ac_dA='s,^\([   ]*\)#\([        ]*define[       ][      ]*\)'
15672 < ac_dB='[        ].*$,\1#\2'
15671 > ac_dA='s,^\([    ]*\)#\([        ]*define[       ][      ]*\)'
15672 > ac_dB='[         ].*$,\1#\2'
15673   ac_dC=' '
15674   ac_dD=',;t'
15675   # ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".
15676 < ac_uA='s,^\([   ]*\)#\([        ]*\)undef\([    ][      ]*\)'
15676 > ac_uA='s,^\([    ]*\)#\([        ]*\)undef\([    ][      ]*\)'
15677   ac_uB='$,\1#\2define\3'
15678   ac_uC=' '
15679   ac_uD=',;t'
# Line 8934 | Line 15682 | for ac_file in : $CONFIG_HEADERS; do test "x$ac_file"
15682    # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
15683    case $ac_file in
15684    - | *:- | *:-:* ) # input from stdin
15685 <        cat >$tmp/stdin
15686 <        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15687 <        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15685 >        cat >$tmp/stdin
15686 >        ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15687 >        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15688    *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
15689 <        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15689 >        ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
15690    * )   ac_file_in=$ac_file.in ;;
15691    esac
15692  
# Line 8952 | Line 15700 | echo "$as_me: creating $ac_file" >&6;}
15700        case $f in
15701        -) echo $tmp/stdin ;;
15702        [\\/$]*)
15703 <         # Absolute (can't be DOS-style, as IFS=:)
15704 <         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15703 >         # Absolute (can't be DOS-style, as IFS=:)
15704 >         test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15705   echo "$as_me: error: cannot find input file: $f" >&2;}
15706     { (exit 1); exit 1; }; }
15707 <         echo $f;;
15707 >         # Do quote $f, to prevent DOS paths from being IFS'd.
15708 >         echo "$f";;
15709        *) # Relative
15710 <         if test -f "$f"; then
15711 <           # Build tree
15712 <           echo $f
15713 <         elif test -f "$srcdir/$f"; then
15714 <           # Source tree
15715 <           echo $srcdir/$f
15716 <         else
15717 <           # /dev/null tree
15718 <           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15710 >         if test -f "$f"; then
15711 >           # Build tree
15712 >           echo "$f"
15713 >         elif test -f "$srcdir/$f"; then
15714 >           # Source tree
15715 >           echo "$srcdir/$f"
15716 >         else
15717 >           # /dev/null tree
15718 >           { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
15719   echo "$as_me: error: cannot find input file: $f" >&2;}
15720     { (exit 1); exit 1; }; }
15721 <         fi;;
15721 >         fi;;
15722        esac
15723      done` || { (exit 1); exit 1; }
15724    # Remove the trailing spaces.
15725 <  sed 's/[      ]*$//' $ac_file_inputs >$tmp/in
15725 >  sed 's/[       ]*$//' $ac_file_inputs >$tmp/in
15726  
15727   _ACEOF
15728  
# Line 8996 | Line 15745 | t clear
15745   s,[\\$`],\\&,g
15746   t clear
15747   : clear
15748 < s,^[    ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
15748 > s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*\)\(([^)]*)\)[       ]*\(.*\)$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp
15749   t end
15750 < s,^[    ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
15750 > s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\)$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp
15751   : end
15752   _ACEOF
15753   # If some macros were called several times there might be several times
# Line 9012 | Line 15761 | cat >>conftest.undefs <<\_ACEOF
15761   # example, in the case of _POSIX_SOURCE, which is predefined and required
15762   # on some systems where configure will not decide to define it.
15763   cat >>conftest.undefs <<\_ACEOF
15764 < s,^[    ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
15764 > s,^[     ]*#[    ]*undef[        ][      ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,
15765   _ACEOF
15766  
15767   # Break up conftest.defines because some shells have a limit on the size
15768   # of here documents, and old seds have small limits too (100 cmds).
15769   echo '  # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS
15770 < echo '  if grep "^[     ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
15770 > echo '  if grep "^[      ]*#[    ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS
15771   echo '  # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS
15772   echo '  :' >>$CONFIG_STATUS
15773   rm -f conftest.tail
# Line 9027 | Line 15776 | do
15776    # Write a limited-size here document to $tmp/defines.sed.
15777    echo '  cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS
15778    # Speed up: don't consider the non `#define' lines.
15779 <  echo '/^[     ]*#[    ]*define/!b' >>$CONFIG_STATUS
15779 >  echo '/^[      ]*#[    ]*define/!b' >>$CONFIG_STATUS
15780    # Work around the forget-to-reset-the-flag bug.
15781    echo 't clr' >>$CONFIG_STATUS
15782    echo ': clr' >>$CONFIG_STATUS
# Line 9054 | Line 15803 | do
15803    # Write a limited-size here document to $tmp/undefs.sed.
15804    echo '  cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS
15805    # Speed up: don't consider the non `#undef'
15806 <  echo '/^[     ]*#[    ]*undef/!b' >>$CONFIG_STATUS
15806 >  echo '/^[      ]*#[    ]*undef/!b' >>$CONFIG_STATUS
15807    # Work around the forget-to-reset-the-flag bug.
15808    echo 't clr' >>$CONFIG_STATUS
15809    echo ': clr' >>$CONFIG_STATUS
# Line 9088 | Line 15837 | $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
15837      else
15838        ac_dir=`(dirname "$ac_file") 2>/dev/null ||
15839   $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15840 <         X"$ac_file" : 'X\(//\)[^/]' \| \
15841 <         X"$ac_file" : 'X\(//\)$' \| \
15842 <         X"$ac_file" : 'X\(/\)' \| \
15843 <         .     : '\(.\)' 2>/dev/null ||
15840 >         X"$ac_file" : 'X\(//\)[^/]' \| \
15841 >         X"$ac_file" : 'X\(//\)$' \| \
15842 >         X"$ac_file" : 'X\(/\)' \| \
15843 >         .     : '\(.\)' 2>/dev/null ||
15844   echo X"$ac_file" |
15845      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15846            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 9107 | Line 15856 | $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
15856        as_dirs="$as_dir $as_dirs"
15857        as_dir=`(dirname "$as_dir") 2>/dev/null ||
15858   $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15859 <         X"$as_dir" : 'X\(//\)[^/]' \| \
15860 <         X"$as_dir" : 'X\(//\)$' \| \
15861 <         X"$as_dir" : 'X\(/\)' \| \
15862 <         .     : '\(.\)' 2>/dev/null ||
15859 >         X"$as_dir" : 'X\(//\)[^/]' \| \
15860 >         X"$as_dir" : 'X\(//\)$' \| \
15861 >         X"$as_dir" : 'X\(/\)' \| \
15862 >         .     : '\(.\)' 2>/dev/null ||
15863   echo X"$as_dir" |
15864      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15865            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 9155 | Line 15904 | $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
15904    # Make relative symlinks.
15905    ac_dest_dir=`(dirname "$ac_dest") 2>/dev/null ||
15906   $as_expr X"$ac_dest" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15907 <         X"$ac_dest" : 'X\(//\)[^/]' \| \
15908 <         X"$ac_dest" : 'X\(//\)$' \| \
15909 <         X"$ac_dest" : 'X\(/\)' \| \
15910 <         .     : '\(.\)' 2>/dev/null ||
15907 >         X"$ac_dest" : 'X\(//\)[^/]' \| \
15908 >         X"$ac_dest" : 'X\(//\)$' \| \
15909 >         X"$ac_dest" : 'X\(/\)' \| \
15910 >         .     : '\(.\)' 2>/dev/null ||
15911   echo X"$ac_dest" |
15912      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15913            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 9174 | Line 15923 | $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
15923        as_dirs="$as_dir $as_dirs"
15924        as_dir=`(dirname "$as_dir") 2>/dev/null ||
15925   $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
15926 <         X"$as_dir" : 'X\(//\)[^/]' \| \
15927 <         X"$as_dir" : 'X\(//\)$' \| \
15928 <         X"$as_dir" : 'X\(/\)' \| \
15929 <         .     : '\(.\)' 2>/dev/null ||
15926 >         X"$as_dir" : 'X\(//\)[^/]' \| \
15927 >         X"$as_dir" : 'X\(//\)$' \| \
15928 >         X"$as_dir" : 'X\(/\)' \| \
15929 >         .     : '\(.\)' 2>/dev/null ||
15930   echo X"$as_dir" |
15931      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
15932            /^X\(\/\/\)[^/].*/{ s//\1/; q; }
# Line 9215 | Line 15964 | esac
15964      ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
15965      ac_top_srcdir=$ac_top_builddir$srcdir ;;
15966   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`
15967  
15968 + # Do not use `cd foo && pwd` to compute absolute paths, because
15969 + # the directories may not exist.
15970 + case `pwd` in
15971 + .) ac_abs_builddir="$ac_dest_dir";;
15972 + *)
15973 +  case "$ac_dest_dir" in
15974 +  .) ac_abs_builddir=`pwd`;;
15975 +  [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dest_dir";;
15976 +  *) ac_abs_builddir=`pwd`/"$ac_dest_dir";;
15977 +  esac;;
15978 + esac
15979 + case $ac_abs_builddir in
15980 + .) ac_abs_top_builddir=${ac_top_builddir}.;;
15981 + *)
15982 +  case ${ac_top_builddir}. in
15983 +  .) ac_abs_top_builddir=$ac_abs_builddir;;
15984 +  [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
15985 +  *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
15986 +  esac;;
15987 + esac
15988 + case $ac_abs_builddir in
15989 + .) ac_abs_srcdir=$ac_srcdir;;
15990 + *)
15991 +  case $ac_srcdir in
15992 +  .) ac_abs_srcdir=$ac_abs_builddir;;
15993 +  [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
15994 +  *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
15995 +  esac;;
15996 + esac
15997 + case $ac_abs_builddir in
15998 + .) ac_abs_top_srcdir=$ac_top_srcdir;;
15999 + *)
16000 +  case $ac_top_srcdir in
16001 +  .) ac_abs_top_srcdir=$ac_abs_builddir;;
16002 +  [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
16003 +  *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
16004 +  esac;;
16005 + esac
16006  
16007 +
16008    case $srcdir in
16009    [\\/$]* | ?:[\\/]* ) ac_rel_source=$srcdir/$ac_source ;;
16010        *) ac_rel_source=$ac_top_builddir$srcdir/$ac_source ;;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines