ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-3.0/configure
(Generate patch)

Comparing trunk/OOPSE-3.0/configure (file contents):
Revision 1499 by gezelter, Tue Sep 28 22:14:11 2004 UTC vs.
Revision 2754 by gezelter, Wed May 17 03:03:03 2006 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.59 for OOPSE 2.0.
3 > # Generated by GNU Autoconf 2.59 for OOPSE 3.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
# Line 269 | Line 269 | PACKAGE_VERSION='2.0'
269   # Identity of this package.
270   PACKAGE_NAME='OOPSE'
271   PACKAGE_TARNAME='oopse'
272 < PACKAGE_VERSION='2.0'
273 < PACKAGE_STRING='OOPSE 2.0'
272 > PACKAGE_VERSION='3.0'
273 > PACKAGE_STRING='OOPSE 3.0'
274   PACKAGE_BUGREPORT='gezelter@nd.edu'
275  
276 < ac_unique_file="src/applications/oopse.cpp"
276 > ac_unique_file="src/applications/oopse/oopse.cpp"
277   ac_default_prefix="/usr/local"
278   # Factoring default headers for most tests.
279   ac_includes_default="\
# Line 312 | Line 312 | ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKA
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 CPP EGREP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT AR 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 BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES ZLIB_INC_DIR ZLIB_LIB_DIR ZLIB FFTW_INC_DIR FFTW_LIB_DIR FFTW_LIBS LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI USE_CGAL CGAL_INC_DIR CGAL_LIB_DIR CGAL_RLIB_DIR CGAL_DEFINES CGAL_CXXFLAGS CGAL_LIBS DOXYGEN DOT DOC enable_dot enable_html_docs enable_latex_docs BATEXT MKINSTALLDIRS OOPSE OOPSE_HOME SUBDIRS LTLIBOBJS'
316   ac_subst_files=''
317  
318   # Initialize some variables set by options.
# Line 753 | Line 753 | ac_env_CC_set=${CC+set}
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 ac_env_CC_set=${CC+set}
757 ac_env_CC_value=$CC
758 ac_cv_env_CC_set=${CC+set}
759 ac_cv_env_CC_value=$CC
760 ac_env_CFLAGS_set=${CFLAGS+set}
761 ac_env_CFLAGS_value=$CFLAGS
762 ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 ac_cv_env_CFLAGS_value=$CFLAGS
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
756   ac_env_CXX_set=${CXX+set}
757   ac_env_CXX_value=$CXX
758   ac_cv_env_CXX_set=${CXX+set}
# Line 777 | Line 761 | ac_env_F90_set=${F90+set}
761   ac_env_CXXFLAGS_value=$CXXFLAGS
762   ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763   ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764 < ac_env_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 797 | Line 801 | if test "$ac_init_help" = "long"; then
801    # Omit some internal or obsolete options to make the list less imposing.
802    # This message is too long to be a string in the A/UX 3.1 sh.
803    cat <<_ACEOF
804 < \`configure' configures OOPSE 2.0 to adapt to many kinds of systems.
804 > \`configure' configures OOPSE 3.0 to adapt to many kinds of systems.
805  
806   Usage: $0 [OPTION]... [VAR=VALUE]...
807  
# Line 858 | Line 862 | if test -n "$ac_init_help"; then
862  
863   if test -n "$ac_init_help"; then
864    case $ac_init_help in
865 <     short | recursive ) echo "Configuration of OOPSE 2.0:";;
865 >     short | recursive ) echo "Configuration of OOPSE 3.0:";;
866     esac
867    cat <<\_ACEOF
868  
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
868  --enable-debug          Compile OOPSE in debug mode
872    --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873 +  --enable-debug          Compile OOPSE in debug mode
874 +  --enable-doxygen        enable documentation generation with doxygen (auto)
875 +  --enable-dot            use 'dot' to generate graphs in doxygen (auto)
876 +  --enable-html-docs      enable HTML generation with doxygen (yes)
877 +  --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
878  
879   Optional Packages:
880    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
881    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882 +  --with-perl-shebang     override what perl thinks is the way for the kernel
883 +                          to start it (seldom needed)
884 +  --with-zlib=DIR         root directory path of zlib installation (defaults
885 +                          to /usr/local or /usr if not found in /usr/local)
886 +  --with-fftw=DIR         root directory path of fftw installation (defaults
887 +                          to /usr/local or /usr if not found in /usr/local)
888    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
889 <  --with-sprng=<prefix>   compile with SPRNG installed in <prefix>
876 <                          [default=/usr/local]
877 <  --with-mkl              Do we want MKL will check /usr/local/intel/mkl61 /opt/intel/mkl61
889 >  --with-cgal-makefile=FILE  CGAL makefile that should be used
890  
891   Some influential environment variables:
892 <  CC          C compiler command
893 <  CFLAGS      C compiler flags
892 >  CXX         C++ compiler command
893 >  CXXFLAGS    C++ compiler flags
894    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
895                nonstandard directory <lib dir>
896    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
897                headers in a nonstandard directory <include dir>
898 <  CXX         C++ compiler command
899 <  CXXFLAGS    C++ compiler flags
900 <  F90         Fortran 90 compiler command
901 <  F90FLAGS    Fortran 90 compiler flags
898 >  CC          C compiler command
899 >  CFLAGS      C compiler flags
900 >  FC          Fortran compiler command
901 >  FCFLAGS     Fortran compiler flags
902    CPP         C preprocessor
903 +  CXXCPP      C++ preprocessor
904  
905   Use these variables to override the choices made by `configure' or to help
906   it to find libraries and programs with nonstandard names/locations.
# Line 988 | Line 1001 | OOPSE configure 2.0
1001   test -n "$ac_init_help" && exit 0
1002   if $ac_init_version; then
1003    cat <<\_ACEOF
1004 < OOPSE configure 2.0
1004 > OOPSE configure 3.0
1005   generated by GNU Autoconf 2.59
1006  
1007   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1002 | Line 1015 | It was created by OOPSE $as_me 2.0, which was
1015   This file contains any messages produced by compilers while
1016   running configure, to aid debugging if configure makes a mistake.
1017  
1018 < It was created by OOPSE $as_me 2.0, which was
1018 > It was created by OOPSE $as_me 3.0, which was
1019   generated by GNU Autoconf 2.59.  Invocation command line was
1020  
1021    $ $0 $@
# Line 1362 | Line 1375 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1375   ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1376   ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1377   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1365
1366
1367 # This file is part of Autoconf.                       -*- Autoconf -*-
1368 # Programming languages support.
1369 # Copyright 2000, 2001
1370 # Free Software Foundation, Inc.
1371 #
1372 # This program is free software; you can redistribute it and/or modify
1373 # it under the terms of the GNU General Public License as published by
1374 # the Free Software Foundation; either version 2, or (at your option)
1375 # any later version.
1376 #
1377 # This program is distributed in the hope that it will be useful,
1378 # but WITHOUT ANY WARRANTY; without even the implied warranty of
1379 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1380 # GNU General Public License for more details.
1381 #
1382 # You should have received a copy of the GNU General Public License
1383 # along with this program; if not, write to the Free Software
1384 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1385 # 02111-1307, USA.
1386 #
1387 # As a special exception, the Free Software Foundation gives unlimited
1388 # permission to copy, distribute and modify the configure scripts that
1389 # are the output of Autoconf.  You need not follow the terms of the GNU
1390 # General Public License when using or distributing such scripts, even
1391 # though portions of the text of Autoconf appear in them.  The GNU
1392 # General Public License (GPL) does govern all other use of the material
1393 # that constitutes the Autoconf program.
1394 #
1395 # Certain portions of the Autoconf source text are designed to be copied
1396 # (in certain cases, depending on the input) into the output of
1397 # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1398 # source text consists of comments plus executable code that decides which
1399 # of the data portions to output in any given case.  We call these
1400 # comments and executable code the "non-data" portions.  Autoconf never
1401 # copies any of the non-data portions into its output.
1402 #
1403 # This special exception to the GPL applies to versions of Autoconf
1404 # released by the Free Software Foundation.  When you make and
1405 # distribute a modified version of Autoconf, you may extend this special
1406 # exception to the GPL to apply to your modified version as well, *unless*
1407 # your modified version has the potential to copy into its output some
1408 # of the text that was the non-data portion of the version that you started
1409 # with.  (In other words, unless your change moves or copies text from
1410 # the non-data portions to the data portions.)  If your modification has
1411 # such potential, you must delete any notice of this special exception
1412 # to the GPL from your modified version.
1413 #
1414 # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1415 # many others).
1378  
1379  
1380 < # Table of Contents:
1419 < #
1420 < # 1. Language selection
1421 < #    and routines to produce programs in a given language.
1422 < #  a. Fortran 77 (to be moved from aclang.m4)
1423 < #  b. Fortran 90
1424 < #  c. Fortran 95
1425 < #
1426 < # 2. Producing programs in a given language.
1427 < #  a. Fortran 77 (to be moved from aclang.m4)
1428 < #  b. Fortran 90
1429 < #  c. Fortran 95
1430 < #
1431 < # 3. Looking for a compiler
1432 < #    And possibly the associated preprocessor.
1433 < #  a. Fortran 77 (to be moved from aclang.m4)
1434 < #  b. Fortran 90
1435 < #  c. Fortran 95
1436 < #
1437 < # 4. Compilers' characteristics.
1438 < #  a. Fortran 77 (to be moved from aclang.m4)
1439 < #  b. Fortran 90
1440 < #  c. Fortran 95
1380 >          ac_config_headers="$ac_config_headers src/config.h"
1381  
1442 # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1443 # ---------------------------------------------------------------------------
1444 #
1445 # Processing the elements of a list is tedious in shell programming,
1446 # as lists tend to be implemented as space delimited strings.
1447 #
1448 # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1449 # if ELEMENT is a member of LIST, otherwise it executes
1450 # ACTION-IF-NOT-FOUND.
1451 # _AC_LIST_MEMBER_IF
1382  
1383  
1384  
1455 # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1456 # -------------------------------------------------
1457 #
1458 # Specifying options to the compiler (whether it be the C, C++ or
1459 # Fortran 77 compiler) that are meant for the linker is compiler
1460 # dependent.  This macro lets you give options to the compiler that
1461 # are meant for the linker in a portable, compiler-independent way.
1462 #
1463 # This macro take two arguments, a list of linker options that the
1464 # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1465 # a shell variable (SHELL-VARIABLE).  The list of linker options are
1466 # appended to the shell variable in a compiler-dependent way.
1467 #
1468 # For example, if the selected language is C, then this:
1469 #
1470 #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1471 #
1472 # will expand into this if the selected C compiler is gcc:
1473 #
1474 #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1475 #
1476 # otherwise, it will expand into this:
1477 #
1478 #   foo_LDFLAGS"-R /usr/local/lib/foo"
1479 #
1480 # You are encouraged to add support for compilers that this macro
1481 # doesn't currently support.
1482 # FIXME: Get rid of this macro.
1483 # _AC_LINKER_OPTION
1385  
1386  
1387  
1487 ## ----------------------- ##
1488 ## 1. Language selection.  ##
1489 ## ----------------------- ##
1388  
1491 # ----------------------------- #
1492 # 1b. The Fortran 90 language.  #
1493 # ----------------------------- #
1389  
1495 # AC_LANG(Fortran 90)
1496 # -------------------
1390  
1391  
1392  
1500 # _AC_LANG_ABBREV(Fortran 90)
1501 # ---------------------------
1393  
1394  
1395  
1505 # ----------------------------- #
1506 # 1c. The Fortran 95 language.  #
1507 # ----------------------------- #
1396  
1509 # AC_LANG(Fortran 95)
1510 # -------------------
1397  
1398  
1399  
1514 # _AC_LANG_ABBREV(Fortran 95)
1515 # ---------------------------
1400  
1401  
1402  
1519 ## ---------------------- ##
1520 ## 2.Producing programs.  ##
1521 ## ---------------------- ##
1403  
1523 # ------------------------ #
1524 # 2b. Fortran 90 sources.  #
1525 # ------------------------ #
1404  
1527 # AC_LANG_SOURCE(Fortran 90)(BODY)
1528 # --------------------------------
1405  
1406  
1407  
1532 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1533 # -----------------------------------------------
1408  
1409  
1536 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1537 # --------------------------------------------
1410  
1411  
1412  
1541 # ------------------------ #
1542 # 2c. Fortran 95 sources.  #
1543 # ------------------------ #
1413  
1545 # AC_LANG_SOURCE(Fortran 95)(BODY)
1546 # --------------------------------
1414  
1415  
1549 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1550 # -----------------------------------------------
1551
1552
1553 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1554 # --------------------------------------------
1555
1556
1557
1558 ## -------------------------------------------- ##
1559 ## 3. Looking for Compilers and Preprocessors.  ##
1560 ## -------------------------------------------- ##
1416  
1562 # ----------------------------- #
1563 # 3b. The Fortran 90 compiler.  #
1564 # ----------------------------- #
1417  
1418  
1567 # AC_LANG_PREPROC(Fortran 90)
1568 # ---------------------------
1569 # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1419  
1420  
1421  
1573 # AC_LANG_COMPILER(Fortran 90)
1574 # ----------------------------
1575 # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1576 # AC_REQUIRE'able.
1422  
1423  
1424  
1580 # AC_PROG_F90([COMPILERS...])
1581 # ---------------------------
1582 # COMPILERS is a space separated list of Fortran 90 compilers to search
1583 # for.
1425   #
1585 # Compilers are ordered by
1586 #  1. F90, F95
1587 #  2. Good/tested native compilers, bad/untested native compilers
1426   #
1427 < # pgf90 is the Portland Group F90 compilers.
1590 < # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1591 < # lf95 is the Lahey-Fujitsu compiler.
1592 < # epcf90 is the "Edinburgh Portable Compiler" F90.
1593 < # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1594 < # AC_PROG_F90
1427 > #
1428  
1429  
1597 # ----------------------------- #
1598 # 3c. The Fortran 95 compiler.  #
1599 # ----------------------------- #
1430  
1431  
1602 # AC_LANG_PREPROC(Fortran 95)
1603 # ---------------------------
1604 # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1432  
1433  
1434 <
1435 < # AC_LANG_COMPILER(Fortran 95)
1609 < # ----------------------------
1610 < # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1611 < # AC_REQUIRE'able.
1612 <
1613 <
1614 <
1615 < # AC_PROG_F95([COMPILERS...])
1616 < # ---------------------------
1617 < # COMPILERS is a space separated list of Fortran 95 compilers to search
1618 < # for.
1434 > # AC_F90_MODULE_NAMES
1435 > # -------------------
1436   #
1437 < # Compilers are ordered by
1621 < #  1. Good/tested native compilers, bad/untested native compilers
1437 > # Figure out how the Fortran 90 compiler constructs module file names
1438   #
1439 < # xlf95 is the IBM (AIX) F95 compiler.
1624 < # lf95 is the Lahey-Fujitsu compiler.
1625 < # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1626 < # AC_PROG_F95
1439 > # AC_F90_MODULE_NAMES
1440  
1441  
1629 ## ------------------------------- ##
1630 ## 4. Compilers' characteristics.  ##
1631 ## ------------------------------- ##
1442  
1443  
1634 # ---------------------------------------- #
1635 # 4b. Fortan 90 compiler characteristics.  #
1636 # ---------------------------------------- #
1444  
1445  
1639 # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1640 # -------------------------------------------------
1641 # Link a trivial Fortran program, compiling with a verbose output FLAG
1642 # (which default value, $ac_cv_prog_f90_v, is computed by
1643 # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1644 # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1645 # so that any link flags that are echoed by the compiler appear as
1646 # space-separated items.
1647 # _AC_PROG_F90_V_OUTPUT
1446  
1447  
1650 # _AC_PROG_F90_V
1651 # --------------
1652 #
1653 # Determine the flag that causes the Fortran 90 compiler to print
1654 # information of library and object files (normally -v)
1655 # Needed for AC_F90_LIBRARY_FLAGS
1656 # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1657 # _AC_PROG_F90_V
1448  
1449  
1660 # AC_F90_LIBRARY_LDFLAGS
1661 # ----------------------
1662 #
1663 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1664 # intrinsic and run-time libraries that are required to successfully
1665 # link a Fortran 90 program or shared library.  The output variable
1666 # F90LIBS is set to these flags.
1667 #
1668 # This macro is intended to be used in those situations when it is
1669 # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1670 # program or shared library.
1671 #
1672 # For example, if object files from a C++ and Fortran 90 compiler must
1673 # be linked together, then the C++ compiler/linker must be used for
1674 # linking (since special C++-ish things need to happen at link time
1675 # like calling global constructors, instantiating templates, enabling
1676 # exception support, etc.).
1677 #
1678 # However, the Fortran 90 intrinsic and run-time libraries must be
1679 # linked in as well, but the C++ compiler/linker doesn't know how to
1680 # add these Fortran 90 libraries.  Hence, the macro
1681 # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1682 # libraries.
1683 #
1684 # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1685 # AC_F90_LIBRARY_LDFLAGS
1450  
1451  
1688 # _AC_F90_NAME_MANGLING
1689 # ---------------------
1690 # Test for the name mangling scheme used by the Fortran 90 compiler.
1691 #
1692 # Sets ac_cv_f90_mangling. The value contains three fields, separated
1693 # by commas:
1694 #
1695 # lower case / upper case:
1696 #    case translation of the Fortan 90 symbols
1697 # underscore / no underscore:
1698 #    whether the compiler appends "_" to symbol names
1699 # extra underscore / no extra underscore:
1700 #    whether the compiler appends an extra "_" to symbol names already
1701 #    containing at least one underscore
1702 #
1703 # _AC_F90_NAME_MANGLING
1452  
1705 # The replacement is empty.
1453  
1454  
1455  
1709 # AC_F90_WRAPPERS
1710 # ---------------
1711 # Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1712 # properly mangle the names of C identifiers, and C identifiers with
1713 # underscores, respectively, so that they match the name mangling
1714 # scheme used by the Fortran 90 compiler.
1715 # AC_F90_WRAPPERS
1456  
1457  
1718 # AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1719 # ------------------------------------
1720 # For a Fortran subroutine of given NAME, define a shell variable
1721 # $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1722 # argument is not supplied, it defaults to NAME.
1723 # AC_F90_FUNC
1458  
1459  
1726 # ---------------------------------------- #
1727 # 4c. Fortan 95 compiler characteristics.  #
1728 # ---------------------------------------- #
1460  
1461  
1731 # _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1732 # -------------------------------------------------
1733 # Link a trivial Fortran program, compiling with a verbose output FLAG
1734 # (which default value, $ac_cv_prog_f95_v, is computed by
1735 # _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1736 # output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1737 # so that any link flags that are echoed by the compiler appear as
1738 # space-separated items.
1739 # _AC_PROG_F95_V_OUTPUT
1462  
1463  
1742 # _AC_PROG_F95_V
1743 # --------------
1744 #
1745 # Determine the flag that causes the Fortran 95 compiler to print
1746 # information of library and object files (normally -v)
1747 # Needed for AC_F95_LIBRARY_FLAGS
1748 # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1749 # _AC_PROG_F95_V
1464  
1465  
1752 # AC_F95_LIBRARY_LDFLAGS
1753 # ----------------------
1754 #
1755 # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1756 # intrinsic and run-time libraries that are required to successfully
1757 # link a Fortran 95 program or shared library.  The output variable
1758 # F95LIBS is set to these flags.
1759 #
1760 # This macro is intended to be used in those situations when it is
1761 # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1762 # program or shared library.
1763 #
1764 # For example, if object files from a C++ and Fortran 95 compiler must
1765 # be linked together, then the C++ compiler/linker must be used for
1766 # linking (since special C++-ish things need to happen at link time
1767 # like calling global constructors, instantiating templates, enabling
1768 # exception support, etc.).
1769 #
1770 # However, the Fortran 95 intrinsic and run-time libraries must be
1771 # linked in as well, but the C++ compiler/linker doesn't know how to
1772 # add these Fortran 95 libraries.  Hence, the macro
1773 # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1774 # libraries.
1775 #
1776 # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1777 # AC_F95_LIBRARY_LDFLAGS
1466  
1467  
1780 # _AC_F95_NAME_MANGLING
1781 # ---------------------
1782 # Test for the name mangling scheme used by the Fortran 95 compiler.
1783 #
1784 # Sets ac_cv_f95_mangling. The value contains three fields, separated
1785 # by commas:
1786 #
1787 # lower case / upper case:
1788 #    case translation of the Fortan 95 symbols
1789 # underscore / no underscore:
1790 #    whether the compiler appends "_" to symbol names
1791 # extra underscore / no extra underscore:
1792 #    whether the compiler appends an extra "_" to symbol names already
1793 #    containing at least one underscore
1794 #
1795 # _AC_F95_NAME_MANGLING
1468  
1797 # The replacement is empty.
1469  
1470  
1471  
1801 # AC_F95_WRAPPERS
1802 # ---------------
1803 # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1804 # properly mangle the names of C identifiers, and C identifiers with
1805 # underscores, respectively, so that they match the name mangling
1806 # scheme used by the Fortran 95 compiler.
1807 # AC_F95_WRAPPERS
1472  
1473  
1810 # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1811 # ------------------------------------
1812 # For a Fortran subroutine of given NAME, define a shell variable
1813 # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1814 # argument is not supplied, it defaults to NAME.
1815 # AC_F95_FUNC
1474  
1475  
1476  
# Line 1867 | Line 1525 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1525  
1526  
1527  
1870
1871 # set program name
1872 PROGNAME="oopse"
1873
1874
1875 # there are two ways to do debugging.  One with the --enable-debug flag
1876 # and one using the DEBUG environment variable
1877
1878 debug=0
1879 # Check whether --enable-debug or --disable-debug was given.
1880 if test "${enable_debug+set}" = set; then
1881  enableval="$enable_debug"
1882  debug=1
1883 fi;
1884 if test "${DEBUG}"; then
1885
1886 cat >>confdefs.h <<\_ACEOF
1887 #define debug 1
1888 _ACEOF
1889
1890  msg="$msg, debug mode"
1891 fi
1892
1893
1528   # who am i
1529   # Make sure we can run config.sub.
1530   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 1947 | Line 1581 | ac_ext=c
1581  
1582  
1583  
1584 < ac_ext=c
1585 < ac_cpp='$CPP $CPPFLAGS'
1586 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1587 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1588 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1584 >
1585 >
1586 > # set program name
1587 > PROGNAME="oopse"
1588 >
1589 >
1590 >
1591 >
1592 > OBJEXT=".$OBJEXT"
1593 >
1594 > OOPSE=oopse
1595 >
1596 > if test "x${prefix}" = "xNONE"
1597 > then
1598 >  OOPSE_HOME=${ac_default_prefix}/oopse
1599 > else
1600 >  OOPSE_HOME=${prefix}/oopse
1601 > fi
1602 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1603 > if test "${enable_oopse_home+set}" = set; then
1604 >  enableval="$enable_oopse_home"
1605 >  OOPSE_HOME="${enableval}"
1606 > fi;
1607 >
1608 > # there are two ways to do debugging.  One with the --enable-debug flag
1609 > # and one using the DEBUG environment variable
1610 >
1611 > debug=0
1612 > # Check whether --enable-debug or --disable-debug was given.
1613 > if test "${enable_debug+set}" = set; then
1614 >  enableval="$enable_debug"
1615 >  debug=1
1616 > fi;
1617 > if test "${DEBUG}"; then
1618 >
1619 > cat >>confdefs.h <<\_ACEOF
1620 > #define debug 1
1621 > _ACEOF
1622 >
1623 >  msg="$msg, debug mode"
1624 > fi
1625 >
1626 >
1627 > # Checks for programs.
1628 > ac_ext=cc
1629 > ac_cpp='$CXXCPP $CPPFLAGS'
1630 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1631 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1632 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1633   if test -n "$ac_tool_prefix"; then
1634 <  for ac_prog in icc xlc gcc cc
1634 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1635    do
1636      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1637   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1638   echo "$as_me:$LINENO: checking for $ac_word" >&5
1639   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1640 < if test "${ac_cv_prog_CC+set}" = set; then
1640 > if test "${ac_cv_prog_CXX+set}" = set; then
1641    echo $ECHO_N "(cached) $ECHO_C" >&6
1642   else
1643 <  if test -n "$CC"; then
1644 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1643 >  if test -n "$CXX"; then
1644 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1645   else
1646   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1647   for as_dir in $PATH
# Line 1972 | Line 1650 | do
1650    test -z "$as_dir" && as_dir=.
1651    for ac_exec_ext in '' $ac_executable_extensions; do
1652    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1653 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1653 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1654      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1655      break 2
1656    fi
# Line 1981 | Line 1659 | CC=$ac_cv_prog_CC
1659  
1660   fi
1661   fi
1662 < CC=$ac_cv_prog_CC
1663 < if test -n "$CC"; then
1664 <  echo "$as_me:$LINENO: result: $CC" >&5
1665 < echo "${ECHO_T}$CC" >&6
1662 > CXX=$ac_cv_prog_CXX
1663 > if test -n "$CXX"; then
1664 >  echo "$as_me:$LINENO: result: $CXX" >&5
1665 > echo "${ECHO_T}$CXX" >&6
1666   else
1667    echo "$as_me:$LINENO: result: no" >&5
1668   echo "${ECHO_T}no" >&6
1669   fi
1670  
1671 <    test -n "$CC" && break
1671 >    test -n "$CXX" && break
1672    done
1673   fi
1674 < if test -z "$CC"; then
1675 <  ac_ct_CC=$CC
1676 <  for ac_prog in icc xlc gcc cc
1674 > if test -z "$CXX"; then
1675 >  ac_ct_CXX=$CXX
1676 >  for ac_prog in $CCC icpc icc pgCC pathCC c++ xlc++ xlC g++ CC
1677   do
1678    # Extract the first word of "$ac_prog", so it can be a program name with args.
1679   set dummy $ac_prog; ac_word=$2
1680   echo "$as_me:$LINENO: checking for $ac_word" >&5
1681   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1682 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1682 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1683    echo $ECHO_N "(cached) $ECHO_C" >&6
1684   else
1685 <  if test -n "$ac_ct_CC"; then
1686 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1685 >  if test -n "$ac_ct_CXX"; then
1686 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1687   else
1688   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1689   for as_dir in $PATH
# Line 2014 | Line 1692 | do
1692    test -z "$as_dir" && as_dir=.
1693    for ac_exec_ext in '' $ac_executable_extensions; do
1694    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1695 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1695 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1696      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1697      break 2
1698    fi
# Line 2023 | Line 1701 | ac_ct_CC=$ac_cv_prog_ac_ct_CC
1701  
1702   fi
1703   fi
1704 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1705 < if test -n "$ac_ct_CC"; then
1706 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1707 < echo "${ECHO_T}$ac_ct_CC" >&6
1704 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1705 > if test -n "$ac_ct_CXX"; then
1706 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1707 > echo "${ECHO_T}$ac_ct_CXX" >&6
1708   else
1709    echo "$as_me:$LINENO: result: no" >&5
1710   echo "${ECHO_T}no" >&6
1711   fi
1712  
1713 <  test -n "$ac_ct_CC" && break
1713 >  test -n "$ac_ct_CXX" && break
1714   done
1715 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1716  
1717 <  CC=$ac_ct_CC
1717 >  CXX=$ac_ct_CXX
1718   fi
1719  
1720  
2042 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2043 See \`config.log' for more details." >&5
2044 echo "$as_me: error: no acceptable C compiler found in \$PATH
2045 See \`config.log' for more details." >&2;}
2046   { (exit 1); exit 1; }; }
2047
1721   # Provide some information about the compiler.
1722   echo "$as_me:$LINENO:" \
1723 <     "checking for C compiler version" >&5
1723 >     "checking for C++ compiler version" >&5
1724   ac_compiler=`set X $ac_compile; echo $2`
1725   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1726    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2085 | Line 1758 | echo "$as_me:$LINENO: checking for C compiler default
1758   # Try to create an executable without -o first, disregard a.out.
1759   # It will help us diagnose broken compilers, and finding out an intuition
1760   # of exeext.
1761 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1762 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1761 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1762 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1763   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1764   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1765    (eval $ac_link_default) 2>&5
# Line 2129 | Line 1802 | sed 's/^/| /' conftest.$ac_ext >&5
1802    echo "$as_me: failed program was:" >&5
1803   sed 's/^/| /' conftest.$ac_ext >&5
1804  
1805 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1805 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1806   See \`config.log' for more details." >&5
1807 < echo "$as_me: error: C compiler cannot create executables
1807 > echo "$as_me: error: C++ compiler cannot create executables
1808   See \`config.log' for more details." >&2;}
1809     { (exit 77); exit 77; }; }
1810   fi
# Line 2142 | Line 1815 | echo "$as_me:$LINENO: checking whether the C compiler
1815  
1816   # Check the compiler produces executables we can run.  If not, either
1817   # the compiler is broken, or we cross compile.
1818 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1819 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1818 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1819 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1820   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1821   # If not cross compiling, check that we can run a simple program.
1822   if test "$cross_compiling" != yes; then
# Line 2158 | Line 1831 | if test "$cross_compiling" != yes; then
1831      if test "$cross_compiling" = maybe; then
1832          cross_compiling=yes
1833      else
1834 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1834 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1835   If you meant to cross compile, use \`--host'.
1836   See \`config.log' for more details." >&5
1837 < echo "$as_me: error: cannot run C compiled programs.
1837 > echo "$as_me: error: cannot run C++ compiled programs.
1838   If you meant to cross compile, use \`--host'.
1839   See \`config.log' for more details." >&2;}
1840     { (exit 1); exit 1; }; }
# Line 2266 | Line 1939 | echo "$as_me:$LINENO: checking whether we are using th
1939   echo "${ECHO_T}$ac_cv_objext" >&6
1940   OBJEXT=$ac_cv_objext
1941   ac_objext=$OBJEXT
1942 + echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1943 + echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1944 + if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1945 +  echo $ECHO_N "(cached) $ECHO_C" >&6
1946 + else
1947 +  cat >conftest.$ac_ext <<_ACEOF
1948 + /* confdefs.h.  */
1949 + _ACEOF
1950 + cat confdefs.h >>conftest.$ac_ext
1951 + cat >>conftest.$ac_ext <<_ACEOF
1952 + /* end confdefs.h.  */
1953 +
1954 + int
1955 + main ()
1956 + {
1957 + #ifndef __GNUC__
1958 +       choke me
1959 + #endif
1960 +
1961 +  ;
1962 +  return 0;
1963 + }
1964 + _ACEOF
1965 + rm -f conftest.$ac_objext
1966 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1967 +  (eval $ac_compile) 2>conftest.er1
1968 +  ac_status=$?
1969 +  grep -v '^ *+' conftest.er1 >conftest.err
1970 +  rm -f conftest.er1
1971 +  cat conftest.err >&5
1972 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1973 +  (exit $ac_status); } &&
1974 +         { ac_try='test -z "$ac_cxx_werror_flag"
1975 +                         || test ! -s conftest.err'
1976 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1977 +  (eval $ac_try) 2>&5
1978 +  ac_status=$?
1979 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1980 +  (exit $ac_status); }; } &&
1981 +         { ac_try='test -s conftest.$ac_objext'
1982 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
1983 +  (eval $ac_try) 2>&5
1984 +  ac_status=$?
1985 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
1986 +  (exit $ac_status); }; }; then
1987 +  ac_compiler_gnu=yes
1988 + else
1989 +  echo "$as_me: failed program was:" >&5
1990 + sed 's/^/| /' conftest.$ac_ext >&5
1991 +
1992 + ac_compiler_gnu=no
1993 + fi
1994 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
1995 + ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
1996 +
1997 + fi
1998 + echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
1999 + echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2000 + GXX=`test $ac_compiler_gnu = yes && echo yes`
2001 + ac_test_CXXFLAGS=${CXXFLAGS+set}
2002 + ac_save_CXXFLAGS=$CXXFLAGS
2003 + CXXFLAGS="-g"
2004 + echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2005 + echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2006 + if test "${ac_cv_prog_cxx_g+set}" = set; then
2007 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2008 + else
2009 +  cat >conftest.$ac_ext <<_ACEOF
2010 + /* confdefs.h.  */
2011 + _ACEOF
2012 + cat confdefs.h >>conftest.$ac_ext
2013 + cat >>conftest.$ac_ext <<_ACEOF
2014 + /* end confdefs.h.  */
2015 +
2016 + int
2017 + main ()
2018 + {
2019 +
2020 +  ;
2021 +  return 0;
2022 + }
2023 + _ACEOF
2024 + rm -f conftest.$ac_objext
2025 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2026 +  (eval $ac_compile) 2>conftest.er1
2027 +  ac_status=$?
2028 +  grep -v '^ *+' conftest.er1 >conftest.err
2029 +  rm -f conftest.er1
2030 +  cat conftest.err >&5
2031 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2032 +  (exit $ac_status); } &&
2033 +         { ac_try='test -z "$ac_cxx_werror_flag"
2034 +                         || test ! -s conftest.err'
2035 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2036 +  (eval $ac_try) 2>&5
2037 +  ac_status=$?
2038 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2039 +  (exit $ac_status); }; } &&
2040 +         { ac_try='test -s conftest.$ac_objext'
2041 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2042 +  (eval $ac_try) 2>&5
2043 +  ac_status=$?
2044 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2045 +  (exit $ac_status); }; }; then
2046 +  ac_cv_prog_cxx_g=yes
2047 + else
2048 +  echo "$as_me: failed program was:" >&5
2049 + sed 's/^/| /' conftest.$ac_ext >&5
2050 +
2051 + ac_cv_prog_cxx_g=no
2052 + fi
2053 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2054 + fi
2055 + echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2056 + echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2057 + if test "$ac_test_CXXFLAGS" = set; then
2058 +  CXXFLAGS=$ac_save_CXXFLAGS
2059 + elif test $ac_cv_prog_cxx_g = yes; then
2060 +  if test "$GXX" = yes; then
2061 +    CXXFLAGS="-g -O2"
2062 +  else
2063 +    CXXFLAGS="-g"
2064 +  fi
2065 + else
2066 +  if test "$GXX" = yes; then
2067 +    CXXFLAGS="-O2"
2068 +  else
2069 +    CXXFLAGS=
2070 +  fi
2071 + fi
2072 + for ac_declaration in \
2073 +   '' \
2074 +   'extern "C" void std::exit (int) throw (); using std::exit;' \
2075 +   'extern "C" void std::exit (int); using std::exit;' \
2076 +   'extern "C" void exit (int) throw ();' \
2077 +   'extern "C" void exit (int);' \
2078 +   'void exit (int);'
2079 + do
2080 +  cat >conftest.$ac_ext <<_ACEOF
2081 + /* confdefs.h.  */
2082 + _ACEOF
2083 + cat confdefs.h >>conftest.$ac_ext
2084 + cat >>conftest.$ac_ext <<_ACEOF
2085 + /* end confdefs.h.  */
2086 + $ac_declaration
2087 + #include <stdlib.h>
2088 + int
2089 + main ()
2090 + {
2091 + exit (42);
2092 +  ;
2093 +  return 0;
2094 + }
2095 + _ACEOF
2096 + rm -f conftest.$ac_objext
2097 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2098 +  (eval $ac_compile) 2>conftest.er1
2099 +  ac_status=$?
2100 +  grep -v '^ *+' conftest.er1 >conftest.err
2101 +  rm -f conftest.er1
2102 +  cat conftest.err >&5
2103 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2104 +  (exit $ac_status); } &&
2105 +         { ac_try='test -z "$ac_cxx_werror_flag"
2106 +                         || test ! -s conftest.err'
2107 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2108 +  (eval $ac_try) 2>&5
2109 +  ac_status=$?
2110 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2111 +  (exit $ac_status); }; } &&
2112 +         { ac_try='test -s conftest.$ac_objext'
2113 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2114 +  (eval $ac_try) 2>&5
2115 +  ac_status=$?
2116 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2117 +  (exit $ac_status); }; }; then
2118 +  :
2119 + else
2120 +  echo "$as_me: failed program was:" >&5
2121 + sed 's/^/| /' conftest.$ac_ext >&5
2122 +
2123 + continue
2124 + fi
2125 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2126 +  cat >conftest.$ac_ext <<_ACEOF
2127 + /* confdefs.h.  */
2128 + _ACEOF
2129 + cat confdefs.h >>conftest.$ac_ext
2130 + cat >>conftest.$ac_ext <<_ACEOF
2131 + /* end confdefs.h.  */
2132 + $ac_declaration
2133 + int
2134 + main ()
2135 + {
2136 + exit (42);
2137 +  ;
2138 +  return 0;
2139 + }
2140 + _ACEOF
2141 + rm -f conftest.$ac_objext
2142 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2143 +  (eval $ac_compile) 2>conftest.er1
2144 +  ac_status=$?
2145 +  grep -v '^ *+' conftest.er1 >conftest.err
2146 +  rm -f conftest.er1
2147 +  cat conftest.err >&5
2148 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2149 +  (exit $ac_status); } &&
2150 +         { ac_try='test -z "$ac_cxx_werror_flag"
2151 +                         || test ! -s conftest.err'
2152 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2153 +  (eval $ac_try) 2>&5
2154 +  ac_status=$?
2155 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2156 +  (exit $ac_status); }; } &&
2157 +         { ac_try='test -s conftest.$ac_objext'
2158 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2159 +  (eval $ac_try) 2>&5
2160 +  ac_status=$?
2161 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2162 +  (exit $ac_status); }; }; then
2163 +  break
2164 + else
2165 +  echo "$as_me: failed program was:" >&5
2166 + sed 's/^/| /' conftest.$ac_ext >&5
2167 +
2168 + fi
2169 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2170 + done
2171 + rm -f conftest*
2172 + if test -n "$ac_declaration"; then
2173 +  echo '#ifdef __cplusplus' >>confdefs.h
2174 +  echo $ac_declaration      >>confdefs.h
2175 +  echo '#endif'             >>confdefs.h
2176 + fi
2177 +
2178 + ac_ext=c
2179 + ac_cpp='$CPP $CPPFLAGS'
2180 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2181 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2182 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2183 +
2184 + ac_ext=c
2185 + ac_cpp='$CPP $CPPFLAGS'
2186 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2187 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2188 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2189 + if test -n "$ac_tool_prefix"; then
2190 +  for ac_prog in icc pgcc pathcc cc xlc gcc
2191 +  do
2192 +    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2193 + set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2194 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2195 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2196 + if test "${ac_cv_prog_CC+set}" = set; then
2197 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2198 + else
2199 +  if test -n "$CC"; then
2200 +  ac_cv_prog_CC="$CC" # Let the user override the test.
2201 + else
2202 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2203 + for as_dir in $PATH
2204 + do
2205 +  IFS=$as_save_IFS
2206 +  test -z "$as_dir" && as_dir=.
2207 +  for ac_exec_ext in '' $ac_executable_extensions; do
2208 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2209 +    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2210 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2211 +    break 2
2212 +  fi
2213 + done
2214 + done
2215 +
2216 + fi
2217 + fi
2218 + CC=$ac_cv_prog_CC
2219 + if test -n "$CC"; then
2220 +  echo "$as_me:$LINENO: result: $CC" >&5
2221 + echo "${ECHO_T}$CC" >&6
2222 + else
2223 +  echo "$as_me:$LINENO: result: no" >&5
2224 + echo "${ECHO_T}no" >&6
2225 + fi
2226 +
2227 +    test -n "$CC" && break
2228 +  done
2229 + fi
2230 + if test -z "$CC"; then
2231 +  ac_ct_CC=$CC
2232 +  for ac_prog in icc pgcc pathcc cc xlc gcc
2233 + do
2234 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
2235 + set dummy $ac_prog; ac_word=$2
2236 + echo "$as_me:$LINENO: checking for $ac_word" >&5
2237 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2238 + if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2239 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2240 + else
2241 +  if test -n "$ac_ct_CC"; then
2242 +  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2243 + else
2244 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2245 + for as_dir in $PATH
2246 + do
2247 +  IFS=$as_save_IFS
2248 +  test -z "$as_dir" && as_dir=.
2249 +  for ac_exec_ext in '' $ac_executable_extensions; do
2250 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2251 +    ac_cv_prog_ac_ct_CC="$ac_prog"
2252 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2253 +    break 2
2254 +  fi
2255 + done
2256 + done
2257 +
2258 + fi
2259 + fi
2260 + ac_ct_CC=$ac_cv_prog_ac_ct_CC
2261 + if test -n "$ac_ct_CC"; then
2262 +  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2263 + echo "${ECHO_T}$ac_ct_CC" >&6
2264 + else
2265 +  echo "$as_me:$LINENO: result: no" >&5
2266 + echo "${ECHO_T}no" >&6
2267 + fi
2268 +
2269 +  test -n "$ac_ct_CC" && break
2270 + done
2271 +
2272 +  CC=$ac_ct_CC
2273 + fi
2274 +
2275 +
2276 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2277 + See \`config.log' for more details." >&5
2278 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2279 + See \`config.log' for more details." >&2;}
2280 +   { (exit 1); exit 1; }; }
2281 +
2282 + # Provide some information about the compiler.
2283 + echo "$as_me:$LINENO:" \
2284 +     "checking for C compiler version" >&5
2285 + ac_compiler=`set X $ac_compile; echo $2`
2286 + { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2287 +  (eval $ac_compiler --version </dev/null >&5) 2>&5
2288 +  ac_status=$?
2289 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2290 +  (exit $ac_status); }
2291 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2292 +  (eval $ac_compiler -v </dev/null >&5) 2>&5
2293 +  ac_status=$?
2294 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2295 +  (exit $ac_status); }
2296 + { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2297 +  (eval $ac_compiler -V </dev/null >&5) 2>&5
2298 +  ac_status=$?
2299 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2300 +  (exit $ac_status); }
2301 +
2302   echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2303   echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2304   if test "${ac_cv_c_compiler_gnu+set}" = set; then
# Line 2660 | Line 2693 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
2693   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2694   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2695  
2696 <
2697 < ac_ext=cc
2698 < ac_cpp='$CXXCPP $CPPFLAGS'
2699 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2667 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2668 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2696 > ac_ext=${FC_SRCEXT-f}
2697 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2698 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2699 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2700   if test -n "$ac_tool_prefix"; then
2701 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2701 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2702    do
2703      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2704   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2705   echo "$as_me:$LINENO: checking for $ac_word" >&5
2706   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2707 < if test "${ac_cv_prog_CXX+set}" = set; then
2707 > if test "${ac_cv_prog_FC+set}" = set; then
2708    echo $ECHO_N "(cached) $ECHO_C" >&6
2709   else
2710 <  if test -n "$CXX"; then
2711 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2710 >  if test -n "$FC"; then
2711 >  ac_cv_prog_FC="$FC" # Let the user override the test.
2712   else
2713   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2714   for as_dir in $PATH
# Line 2686 | Line 2717 | do
2717    test -z "$as_dir" && as_dir=.
2718    for ac_exec_ext in '' $ac_executable_extensions; do
2719    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2720 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2720 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2721      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2722      break 2
2723    fi
# Line 2695 | Line 2726 | CXX=$ac_cv_prog_CXX
2726  
2727   fi
2728   fi
2729 < CXX=$ac_cv_prog_CXX
2730 < if test -n "$CXX"; then
2731 <  echo "$as_me:$LINENO: result: $CXX" >&5
2732 < echo "${ECHO_T}$CXX" >&6
2729 > FC=$ac_cv_prog_FC
2730 > if test -n "$FC"; then
2731 >  echo "$as_me:$LINENO: result: $FC" >&5
2732 > echo "${ECHO_T}$FC" >&6
2733   else
2734    echo "$as_me:$LINENO: result: no" >&5
2735   echo "${ECHO_T}no" >&6
2736   fi
2737  
2738 <    test -n "$CXX" && break
2738 >    test -n "$FC" && break
2739    done
2740   fi
2741 < if test -z "$CXX"; then
2742 <  ac_ct_CXX=$CXX
2743 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2741 > if test -z "$FC"; then
2742 >  ac_ct_FC=$FC
2743 >  for ac_prog in ifort ifc pgf95 pathf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2744   do
2745    # Extract the first word of "$ac_prog", so it can be a program name with args.
2746   set dummy $ac_prog; ac_word=$2
2747   echo "$as_me:$LINENO: checking for $ac_word" >&5
2748   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2749 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2749 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2750    echo $ECHO_N "(cached) $ECHO_C" >&6
2751   else
2752 <  if test -n "$ac_ct_CXX"; then
2753 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2752 >  if test -n "$ac_ct_FC"; then
2753 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2754   else
2755   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2756   for as_dir in $PATH
# Line 2728 | Line 2759 | do
2759    test -z "$as_dir" && as_dir=.
2760    for ac_exec_ext in '' $ac_executable_extensions; do
2761    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2762 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2762 >    ac_cv_prog_ac_ct_FC="$ac_prog"
2763      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2764      break 2
2765    fi
# Line 2737 | Line 2768 | ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2768  
2769   fi
2770   fi
2771 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2772 < if test -n "$ac_ct_CXX"; then
2773 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2774 < echo "${ECHO_T}$ac_ct_CXX" >&6
2775 < else
2776 <  echo "$as_me:$LINENO: result: no" >&5
2771 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
2772 > if test -n "$ac_ct_FC"; then
2773 >  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2774 > echo "${ECHO_T}$ac_ct_FC" >&6
2775 > else
2776 >  echo "$as_me:$LINENO: result: no" >&5
2777   echo "${ECHO_T}no" >&6
2778   fi
2779  
2780 <  test -n "$ac_ct_CXX" && break
2780 >  test -n "$ac_ct_FC" && break
2781   done
2751 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2782  
2783 <  CXX=$ac_ct_CXX
2783 >  FC=$ac_ct_FC
2784   fi
2785  
2786  
2787   # Provide some information about the compiler.
2788 < echo "$as_me:$LINENO:" \
2789 <     "checking for C++ compiler version" >&5
2788 > echo "$as_me:2788:" \
2789 >     "checking for Fortran compiler version" >&5
2790   ac_compiler=`set X $ac_compile; echo $2`
2791   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2792    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2773 | Line 2803 | ac_compiler=`set X $ac_compile; echo $2`
2803    ac_status=$?
2804    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2805    (exit $ac_status); }
2806 + rm -f a.out
2807  
2808 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2809 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2810 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2808 > # If we don't use `.F' as extension, the preprocessor is not run on the
2809 > # input file.  (Note that this only needs to work for GNU compilers.)
2810 > ac_save_ext=$ac_ext
2811 > ac_ext=F
2812 > echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2813 > echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2814 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2815    echo $ECHO_N "(cached) $ECHO_C" >&6
2816   else
2817    cat >conftest.$ac_ext <<_ACEOF
2818 < /* confdefs.h.  */
2784 < _ACEOF
2785 < cat confdefs.h >>conftest.$ac_ext
2786 < cat >>conftest.$ac_ext <<_ACEOF
2787 < /* end confdefs.h.  */
2788 <
2789 < int
2790 < main ()
2791 < {
2818 >      program main
2819   #ifndef __GNUC__
2820         choke me
2821   #endif
2822  
2823 <  ;
2797 <  return 0;
2798 < }
2823 >      end
2824   _ACEOF
2825   rm -f conftest.$ac_objext
2826   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2806 | Line 2831 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2831    cat conftest.err >&5
2832    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2833    (exit $ac_status); } &&
2834 <         { ac_try='test -z "$ac_cxx_werror_flag"
2834 >         { ac_try='test -z "$ac_fc_werror_flag"
2835                           || test ! -s conftest.err'
2836    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2837    (eval $ac_try) 2>&5
# Line 2827 | Line 2852 | ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2852   ac_compiler_gnu=no
2853   fi
2854   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2855 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2855 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2856  
2857   fi
2858 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2859 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2860 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2861 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2862 < ac_save_CXXFLAGS=$CXXFLAGS
2863 < CXXFLAGS="-g"
2864 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2865 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2866 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2858 > echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2859 > echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2860 > ac_ext=$ac_save_ext
2861 > ac_test_FFLAGS=${FCFLAGS+set}
2862 > ac_save_FFLAGS=$FCFLAGS
2863 > FCFLAGS=
2864 > echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2865 > echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2866 > if test "${ac_cv_prog_fc_g+set}" = set; then
2867    echo $ECHO_N "(cached) $ECHO_C" >&6
2868   else
2869 <  cat >conftest.$ac_ext <<_ACEOF
2870 < /* confdefs.h.  */
2871 < _ACEOF
2847 < cat confdefs.h >>conftest.$ac_ext
2848 < cat >>conftest.$ac_ext <<_ACEOF
2849 < /* end confdefs.h.  */
2869 >  FCFLAGS=-g
2870 > cat >conftest.$ac_ext <<_ACEOF
2871 >      program main
2872  
2873 < int
2852 < main ()
2853 < {
2854 <
2855 <  ;
2856 <  return 0;
2857 < }
2873 >      end
2874   _ACEOF
2875   rm -f conftest.$ac_objext
2876   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 2865 | Line 2881 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2881    cat conftest.err >&5
2882    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2883    (exit $ac_status); } &&
2884 <         { ac_try='test -z "$ac_cxx_werror_flag"
2884 >         { ac_try='test -z "$ac_fc_werror_flag"
2885                           || test ! -s conftest.err'
2886    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2887    (eval $ac_try) 2>&5
# Line 2878 | Line 2894 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2894    ac_status=$?
2895    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2896    (exit $ac_status); }; }; then
2897 <  ac_cv_prog_cxx_g=yes
2897 >  ac_cv_prog_fc_g=yes
2898   else
2899    echo "$as_me: failed program was:" >&5
2900   sed 's/^/| /' conftest.$ac_ext >&5
2901  
2902 < ac_cv_prog_cxx_g=no
2902 > ac_cv_prog_fc_g=no
2903   fi
2904   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2905 +
2906   fi
2907 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2908 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2909 < if test "$ac_test_CXXFLAGS" = set; then
2910 <  CXXFLAGS=$ac_save_CXXFLAGS
2911 < elif test $ac_cv_prog_cxx_g = yes; then
2912 <  if test "$GXX" = yes; then
2913 <    CXXFLAGS="-g -O2"
2907 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2908 > echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2909 > if test "$ac_test_FFLAGS" = set; then
2910 >  FCFLAGS=$ac_save_FFLAGS
2911 > elif test $ac_cv_prog_fc_g = yes; then
2912 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2913 >    FCFLAGS="-g -O2"
2914    else
2915 <    CXXFLAGS="-g"
2915 >    FCFLAGS="-g"
2916    fi
2917   else
2918 <  if test "$GXX" = yes; then
2919 <    CXXFLAGS="-O2"
2918 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2919 >    FCFLAGS="-O2"
2920    else
2921 <    CXXFLAGS=
2921 >    FCFLAGS=
2922    fi
2923   fi
2924 < for ac_declaration in \
2925 <   '' \
2926 <   'extern "C" void std::exit (int) throw (); using std::exit;' \
2927 <   'extern "C" void std::exit (int); using std::exit;' \
2928 <   'extern "C" void exit (int) throw ();' \
2929 <   'extern "C" void exit (int);' \
2930 <   'void exit (int);'
2924 >
2925 > ac_ext=c
2926 > ac_cpp='$CPP $CPPFLAGS'
2927 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2928 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2929 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2930 >
2931 > ac_ext=c
2932 > ac_cpp='$CPP $CPPFLAGS'
2933 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2934 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2935 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2936 > echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2937 > echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2938 > # On Suns, sometimes $CPP names a directory.
2939 > if test -n "$CPP" && test -d "$CPP"; then
2940 >  CPP=
2941 > fi
2942 > if test -z "$CPP"; then
2943 >  if test "${ac_cv_prog_CPP+set}" = set; then
2944 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2945 > else
2946 >      # Double quotes because CPP needs to be expanded
2947 >    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
2948 >    do
2949 >      ac_preproc_ok=false
2950 > for ac_c_preproc_warn_flag in '' yes
2951   do
2952 +  # Use a header file that comes with gcc, so configuring glibc
2953 +  # with a fresh cross-compiler works.
2954 +  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2955 +  # <limits.h> exists even on freestanding compilers.
2956 +  # On the NeXT, cc -E runs the code through the compiler's parser,
2957 +  # not just through cpp. "Syntax error" is here to catch this case.
2958    cat >conftest.$ac_ext <<_ACEOF
2959   /* confdefs.h.  */
2960   _ACEOF
2961   cat confdefs.h >>conftest.$ac_ext
2962   cat >>conftest.$ac_ext <<_ACEOF
2963   /* end confdefs.h.  */
2964 < $ac_declaration
2965 < #include <stdlib.h>
2966 < int
2967 < main ()
2968 < {
2969 < exit (42);
2927 <  ;
2928 <  return 0;
2929 < }
2964 > #ifdef __STDC__
2965 > # include <limits.h>
2966 > #else
2967 > # include <assert.h>
2968 > #endif
2969 >                     Syntax error
2970   _ACEOF
2971 < rm -f conftest.$ac_objext
2972 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2933 <  (eval $ac_compile) 2>conftest.er1
2971 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2972 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2973    ac_status=$?
2974    grep -v '^ *+' conftest.er1 >conftest.err
2975    rm -f conftest.er1
2976    cat conftest.err >&5
2977    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2978 <  (exit $ac_status); } &&
2979 <         { ac_try='test -z "$ac_cxx_werror_flag"
2980 <                         || test ! -s conftest.err'
2981 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2982 <  (eval $ac_try) 2>&5
2983 <  ac_status=$?
2984 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2985 <  (exit $ac_status); }; } &&
2986 <         { ac_try='test -s conftest.$ac_objext'
2987 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2988 <  (eval $ac_try) 2>&5
2950 <  ac_status=$?
2951 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2952 <  (exit $ac_status); }; }; then
2978 >  (exit $ac_status); } >/dev/null; then
2979 >  if test -s conftest.err; then
2980 >    ac_cpp_err=$ac_c_preproc_warn_flag
2981 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
2982 >  else
2983 >    ac_cpp_err=
2984 >  fi
2985 > else
2986 >  ac_cpp_err=yes
2987 > fi
2988 > if test -z "$ac_cpp_err"; then
2989    :
2990   else
2991    echo "$as_me: failed program was:" >&5
2992   sed 's/^/| /' conftest.$ac_ext >&5
2993  
2994 +  # Broken: fails on valid input.
2995   continue
2996   fi
2997 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2997 > rm -f conftest.err conftest.$ac_ext
2998 >
2999 >  # OK, works on sane cases.  Now check whether non-existent headers
3000 >  # can be detected and how.
3001    cat >conftest.$ac_ext <<_ACEOF
3002   /* confdefs.h.  */
3003   _ACEOF
3004   cat confdefs.h >>conftest.$ac_ext
3005   cat >>conftest.$ac_ext <<_ACEOF
3006   /* end confdefs.h.  */
3007 < $ac_declaration
2968 < int
2969 < main ()
2970 < {
2971 < exit (42);
2972 <  ;
2973 <  return 0;
2974 < }
3007 > #include <ac_nonexistent.h>
3008   _ACEOF
3009 < rm -f conftest.$ac_objext
3010 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2978 <  (eval $ac_compile) 2>conftest.er1
3009 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3010 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3011    ac_status=$?
3012    grep -v '^ *+' conftest.er1 >conftest.err
3013    rm -f conftest.er1
3014    cat conftest.err >&5
3015    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3016 <  (exit $ac_status); } &&
3017 <         { ac_try='test -z "$ac_cxx_werror_flag"
3018 <                         || test ! -s conftest.err'
3019 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3020 <  (eval $ac_try) 2>&5
3016 >  (exit $ac_status); } >/dev/null; then
3017 >  if test -s conftest.err; then
3018 >    ac_cpp_err=$ac_c_preproc_warn_flag
3019 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3020 >  else
3021 >    ac_cpp_err=
3022 >  fi
3023 > else
3024 >  ac_cpp_err=yes
3025 > fi
3026 > if test -z "$ac_cpp_err"; then
3027 >  # Broken: success on invalid input.
3028 > continue
3029 > else
3030 >  echo "$as_me: failed program was:" >&5
3031 > sed 's/^/| /' conftest.$ac_ext >&5
3032 >
3033 >  # Passes both tests.
3034 > ac_preproc_ok=:
3035 > break
3036 > fi
3037 > rm -f conftest.err conftest.$ac_ext
3038 >
3039 > done
3040 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3041 > rm -f conftest.err conftest.$ac_ext
3042 > if $ac_preproc_ok; then
3043 >  break
3044 > fi
3045 >
3046 >    done
3047 >    ac_cv_prog_CPP=$CPP
3048 >
3049 > fi
3050 >  CPP=$ac_cv_prog_CPP
3051 > else
3052 >  ac_cv_prog_CPP=$CPP
3053 > fi
3054 > echo "$as_me:$LINENO: result: $CPP" >&5
3055 > echo "${ECHO_T}$CPP" >&6
3056 > ac_preproc_ok=false
3057 > for ac_c_preproc_warn_flag in '' yes
3058 > do
3059 >  # Use a header file that comes with gcc, so configuring glibc
3060 >  # with a fresh cross-compiler works.
3061 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3062 >  # <limits.h> exists even on freestanding compilers.
3063 >  # On the NeXT, cc -E runs the code through the compiler's parser,
3064 >  # not just through cpp. "Syntax error" is here to catch this case.
3065 >  cat >conftest.$ac_ext <<_ACEOF
3066 > /* confdefs.h.  */
3067 > _ACEOF
3068 > cat confdefs.h >>conftest.$ac_ext
3069 > cat >>conftest.$ac_ext <<_ACEOF
3070 > /* end confdefs.h.  */
3071 > #ifdef __STDC__
3072 > # include <limits.h>
3073 > #else
3074 > # include <assert.h>
3075 > #endif
3076 >                     Syntax error
3077 > _ACEOF
3078 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3079 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3080    ac_status=$?
3081 +  grep -v '^ *+' conftest.er1 >conftest.err
3082 +  rm -f conftest.er1
3083 +  cat conftest.err >&5
3084    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3085 <  (exit $ac_status); }; } &&
3086 <         { ac_try='test -s conftest.$ac_objext'
3087 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3088 <  (eval $ac_try) 2>&5
3085 >  (exit $ac_status); } >/dev/null; then
3086 >  if test -s conftest.err; then
3087 >    ac_cpp_err=$ac_c_preproc_warn_flag
3088 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3089 >  else
3090 >    ac_cpp_err=
3091 >  fi
3092 > else
3093 >  ac_cpp_err=yes
3094 > fi
3095 > if test -z "$ac_cpp_err"; then
3096 >  :
3097 > else
3098 >  echo "$as_me: failed program was:" >&5
3099 > sed 's/^/| /' conftest.$ac_ext >&5
3100 >
3101 >  # Broken: fails on valid input.
3102 > continue
3103 > fi
3104 > rm -f conftest.err conftest.$ac_ext
3105 >
3106 >  # OK, works on sane cases.  Now check whether non-existent headers
3107 >  # can be detected and how.
3108 >  cat >conftest.$ac_ext <<_ACEOF
3109 > /* confdefs.h.  */
3110 > _ACEOF
3111 > cat confdefs.h >>conftest.$ac_ext
3112 > cat >>conftest.$ac_ext <<_ACEOF
3113 > /* end confdefs.h.  */
3114 > #include <ac_nonexistent.h>
3115 > _ACEOF
3116 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3117 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3118    ac_status=$?
3119 +  grep -v '^ *+' conftest.er1 >conftest.err
3120 +  rm -f conftest.er1
3121 +  cat conftest.err >&5
3122    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3123 <  (exit $ac_status); }; }; then
3124 <  break
3123 >  (exit $ac_status); } >/dev/null; then
3124 >  if test -s conftest.err; then
3125 >    ac_cpp_err=$ac_c_preproc_warn_flag
3126 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3127 >  else
3128 >    ac_cpp_err=
3129 >  fi
3130   else
3131 +  ac_cpp_err=yes
3132 + fi
3133 + if test -z "$ac_cpp_err"; then
3134 +  # Broken: success on invalid input.
3135 + continue
3136 + else
3137    echo "$as_me: failed program was:" >&5
3138   sed 's/^/| /' conftest.$ac_ext >&5
3139  
3140 +  # Passes both tests.
3141 + ac_preproc_ok=:
3142 + break
3143   fi
3144 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3144 > rm -f conftest.err conftest.$ac_ext
3145 >
3146   done
3147 < rm -f conftest*
3148 < if test -n "$ac_declaration"; then
3149 <  echo '#ifdef __cplusplus' >>confdefs.h
3150 <  echo $ac_declaration      >>confdefs.h
3151 <  echo '#endif'             >>confdefs.h
3147 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3148 > rm -f conftest.err conftest.$ac_ext
3149 > if $ac_preproc_ok; then
3150 >  :
3151 > else
3152 >  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3153 > See \`config.log' for more details." >&5
3154 > echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3155 > See \`config.log' for more details." >&2;}
3156 >   { (exit 1); exit 1; }; }
3157   fi
3158  
3159   ac_ext=c
# Line 3016 | Line 3162 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
3162   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3163   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3164  
3165 + echo "$as_me:$LINENO: checking for egrep" >&5
3166 + echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3167 + if test "${ac_cv_prog_egrep+set}" = set; then
3168 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3169 + else
3170 +  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3171 +    then ac_cv_prog_egrep='grep -E'
3172 +    else ac_cv_prog_egrep='egrep'
3173 +    fi
3174 + fi
3175 + echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3176 + echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3177 + EGREP=$ac_cv_prog_egrep
3178  
3179 < OOPSE_TEMPLATE_FLAGS=""
3180 < if test $ac_cv_cxx_compiler_gnu = no; then
3181 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3182 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3183 <  echo 'void f(){}' > conftest.cc
3184 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3026 <    echo "$as_me:$LINENO: result: yes" >&5
3179 >
3180 > echo "$as_me:$LINENO: checking whether ln -s works" >&5
3181 > echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3182 > LN_S=$as_ln_s
3183 > if test "$LN_S" = "ln -s"; then
3184 >  echo "$as_me:$LINENO: result: yes" >&5
3185   echo "${ECHO_T}yes" >&6
3186 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3187 <  else
3188 <    echo "$as_me:$LINENO: result: no" >&5
3189 < echo "${ECHO_T}no" >&6
3190 <  fi
3191 <  rm -f conftest*
3192 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3193 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3194 <  echo 'void f(){}' > conftest.cc
3195 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3196 <    echo "$as_me:$LINENO: result: yes" >&5
3186 > else
3187 >  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3188 > echo "${ECHO_T}no, using $LN_S" >&6
3189 > fi
3190 >
3191 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3192 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3193 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3194 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3195 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3196 > else
3197 >  cat >conftest.make <<\_ACEOF
3198 > all:
3199 >        @echo 'ac_maketemp="$(MAKE)"'
3200 > _ACEOF
3201 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3202 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3203 > if test -n "$ac_maketemp"; then
3204 >  eval ac_cv_prog_make_${ac_make}_set=yes
3205 > else
3206 >  eval ac_cv_prog_make_${ac_make}_set=no
3207 > fi
3208 > rm -f conftest.make
3209 > fi
3210 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3211 >  echo "$as_me:$LINENO: result: yes" >&5
3212   echo "${ECHO_T}yes" >&6
3213 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3214 <  else
3215 <    echo "$as_me:$LINENO: result: no" >&5
3213 >  SET_MAKE=
3214 > else
3215 >  echo "$as_me:$LINENO: result: no" >&5
3216   echo "${ECHO_T}no" >&6
3217 +  SET_MAKE="MAKE=${MAKE-make}"
3218 + fi
3219 +
3220 + if test -n "$ac_tool_prefix"; then
3221 +  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3222 + set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3223 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3224 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3225 + if test "${ac_cv_prog_RANLIB+set}" = set; then
3226 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3227 + else
3228 +  if test -n "$RANLIB"; then
3229 +  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3230 + else
3231 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3232 + for as_dir in $PATH
3233 + do
3234 +  IFS=$as_save_IFS
3235 +  test -z "$as_dir" && as_dir=.
3236 +  for ac_exec_ext in '' $ac_executable_extensions; do
3237 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3238 +    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3239 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3240 +    break 2
3241    fi
3242 <  rm -f conftest*
3243 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3244 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3245 <  echo 'void f(){}' > conftest.cc
3246 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3247 <    echo "$as_me:$LINENO: result: yes" >&5
3248 < echo "${ECHO_T}yes" >&6
3249 <    OOPSE_TEMPLATE_FLAGS="-pto"
3250 <  else
3251 <    echo "$as_me:$LINENO: result: no" >&5
3242 > done
3243 > done
3244 >
3245 > fi
3246 > fi
3247 > RANLIB=$ac_cv_prog_RANLIB
3248 > if test -n "$RANLIB"; then
3249 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3250 > echo "${ECHO_T}$RANLIB" >&6
3251 > else
3252 >  echo "$as_me:$LINENO: result: no" >&5
3253   echo "${ECHO_T}no" >&6
3254 + fi
3255 +
3256 + fi
3257 + if test -z "$ac_cv_prog_RANLIB"; then
3258 +  ac_ct_RANLIB=$RANLIB
3259 +  # Extract the first word of "ranlib", so it can be a program name with args.
3260 + set dummy ranlib; ac_word=$2
3261 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3262 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3263 + if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3264 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3265 + else
3266 +  if test -n "$ac_ct_RANLIB"; then
3267 +  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3268 + else
3269 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3270 + for as_dir in $PATH
3271 + do
3272 +  IFS=$as_save_IFS
3273 +  test -z "$as_dir" && as_dir=.
3274 +  for ac_exec_ext in '' $ac_executable_extensions; do
3275 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3276 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3277 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3278 +    break 2
3279    fi
3280 <  rm -f conftest*
3281 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3059 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3060 <  echo 'void f(){}' > conftest.cc
3061 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3062 <    echo "$as_me:$LINENO: result: yes" >&5
3063 < echo "${ECHO_T}yes" >&6
3280 > done
3281 > done
3282  
3283 +  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3284 + fi
3285 + fi
3286 + ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3287 + if test -n "$ac_ct_RANLIB"; then
3288 +  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3289 + echo "${ECHO_T}$ac_ct_RANLIB" >&6
3290 + else
3291 +  echo "$as_me:$LINENO: result: no" >&5
3292 + echo "${ECHO_T}no" >&6
3293 + fi
3294  
3295 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3296 <  else
3297 <    echo "$as_me:$LINENO: result: no" >&5
3295 >  RANLIB=$ac_ct_RANLIB
3296 > else
3297 >  RANLIB="$ac_cv_prog_RANLIB"
3298 > fi
3299 >
3300 >
3301 >   # Extract the first word of "perl", so it can be a program name with args.
3302 > set dummy perl; ac_word=$2
3303 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3304 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3305 > if test "${ac_cv_path_PERLINTERP+set}" = set; then
3306 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3307 > else
3308 >  case $PERLINTERP in
3309 >  [\\/]* | ?:[\\/]*)
3310 >  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3311 >  ;;
3312 >  *)
3313 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3314 > for as_dir in $PATH
3315 > do
3316 >  IFS=$as_save_IFS
3317 >  test -z "$as_dir" && as_dir=.
3318 >  for ac_exec_ext in '' $ac_executable_extensions; do
3319 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3320 >    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3321 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3322 >    break 2
3323 >  fi
3324 > done
3325 > done
3326 >
3327 >  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3328 >  ;;
3329 > esac
3330 > fi
3331 > PERLINTERP=$ac_cv_path_PERLINTERP
3332 >
3333 > if test -n "$PERLINTERP"; then
3334 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3335 > echo "${ECHO_T}$PERLINTERP" >&6
3336 > else
3337 >  echo "$as_me:$LINENO: result: no" >&5
3338   echo "${ECHO_T}no" >&6
3339 + fi
3340 +
3341 +   ac_cv_path_perlinterp="$PERLINTERP"
3342 +   _sHpB='#!'
3343 +
3344 +
3345 + # Check whether --with-perl-shebang or --without-perl-shebang was given.
3346 + if test "${with_perl_shebang+set}" = set; then
3347 +  withval="$with_perl_shebang"
3348 +  opt_perl_shebang="$withval"
3349 + else
3350 +                opt_perl_shebang="not_set"
3351 + fi;
3352 +   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3353 + echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3354 + if test "${ax_cv_opt_perl_shebang+set}" = set; then
3355 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3356 + else
3357 +   case "$opt_perl_shebang" in
3358 +                      not_set  ) ax_cv_opt_perl_shebang=''
3359 +                               ;;
3360 +                         *     )
3361 +        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3362 +                    esac
3363 +
3364 + fi
3365 + echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3366 + echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3367 +   if test "A$ax_cv_opt_perl_shebang" != "A"
3368 +     then
3369 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3370 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3371 +              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3372 + echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3373 +
3374 + # Automatic detection of sharpbang formula starts here
3375 +     else
3376 +   _somian_shbangperl=`$PERLINTERP -V:startperl`
3377 +   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3378 +   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3379 + echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3380 + if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3381 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3382 + else
3383 +  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3384 +        if test "x$_somian_kspb_perl" == x
3385 +          then _somian_ksbp_warn_empty='durnit'
3386 +          else
3387 +          case "A$_somian_kspb_perl" in
3388 +                 A#!*perl* )
3389 +           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3390 +                        ;;
3391 +                     A*    )  _somian_ksbp_warn_defau='trouble'
3392 +                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3393 +          esac
3394 +        fi
3395 +
3396 + fi
3397 + echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3398 + echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3399 + # The above prints Checking ... result message to user.
3400 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3401 +
3402 +    if test A${_somian_ksbp_warn_empty+set} == Aset
3403 +      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3404 + echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3405 +    fi
3406 + # Inform user after printing result value
3407 +    if test A${_somian_ksbp_warn_defau+set} == Aset
3408 +      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3409 + echo "$as_me: Maybe Not good -" >&6;}
3410 +           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3411 + echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3412 +      else { echo "$as_me:$LINENO: OK Good result - " >&5
3413 + echo "$as_me: OK Good result - " >&6;}
3414 +           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3415 + echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3416 +    fi
3417    fi
3418 +
3419 + # Find a good install program.  We prefer a C program (faster),
3420 + # so one script is as good as another.  But avoid the broken or
3421 + # incompatible versions:
3422 + # SysV /etc/install, /usr/sbin/install
3423 + # SunOS /usr/etc/install
3424 + # IRIX /sbin/install
3425 + # AIX /bin/install
3426 + # AmigaOS /C/install, which installs bootblocks on floppy discs
3427 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3428 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3429 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3430 + # OS/2's system install, which has a completely different semantic
3431 + # ./install, which can be erroneously created by make from ./install.sh.
3432 + echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3433 + echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3434 + if test -z "$INSTALL"; then
3435 + if test "${ac_cv_path_install+set}" = set; then
3436 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3437 + else
3438 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3439 + for as_dir in $PATH
3440 + do
3441 +  IFS=$as_save_IFS
3442 +  test -z "$as_dir" && as_dir=.
3443 +  # Account for people who put trailing slashes in PATH elements.
3444 + case $as_dir/ in
3445 +  ./ | .// | /cC/* | \
3446 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3447 +  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3448 +  /usr/ucb/* ) ;;
3449 +  *)
3450 +    # OSF1 and SCO ODT 3.0 have their own names for install.
3451 +    # Don't use installbsd from OSF since it installs stuff as root
3452 +    # by default.
3453 +    for ac_prog in ginstall scoinst install; do
3454 +      for ac_exec_ext in '' $ac_executable_extensions; do
3455 +        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3456 +          if test $ac_prog = install &&
3457 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3458 +            # AIX install.  It has an incompatible calling convention.
3459 +            :
3460 +          elif test $ac_prog = install &&
3461 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3462 +            # program-specific install script used by HP pwplus--don't use.
3463 +            :
3464 +          else
3465 +            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3466 +            break 3
3467 +          fi
3468 +        fi
3469 +      done
3470 +    done
3471 +    ;;
3472 + esac
3473 + done
3474 +
3475 +
3476   fi
3477 +  if test "${ac_cv_path_install+set}" = set; then
3478 +    INSTALL=$ac_cv_path_install
3479 +  else
3480 +    # As a last resort, use the slow shell script.  We don't cache a
3481 +    # path for INSTALL within a source directory, because that will
3482 +    # break other packages using the cache if that directory is
3483 +    # removed, or if the path is relative.
3484 +    INSTALL=$ac_install_sh
3485 +  fi
3486 + fi
3487 + echo "$as_me:$LINENO: result: $INSTALL" >&5
3488 + echo "${ECHO_T}$INSTALL" >&6
3489  
3490 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3491 + # It thinks the first close brace ends the variable substitution.
3492 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3493  
3494 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3495  
3496 + test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3497  
3498 < ac_ext=f90
3499 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3500 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3501 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3502 < if test -n "$ac_tool_prefix"; then
3503 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3504 <  do
3083 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3084 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3498 > case "x$INSTALL" in
3499 >   x/*) ;;
3500 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3501 > esac
3502 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3503 > # Extract the first word of "ar", so it can be a program name with args.
3504 > set dummy ar; ac_word=$2
3505   echo "$as_me:$LINENO: checking for $ac_word" >&5
3506   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3507 < if test "${ac_cv_prog_F90+set}" = set; then
3507 > if test "${ac_cv_prog_AR+set}" = set; then
3508    echo $ECHO_N "(cached) $ECHO_C" >&6
3509   else
3510 <  if test -n "$F90"; then
3511 <  ac_cv_prog_F90="$F90" # Let the user override the test.
3510 >  if test -n "$AR"; then
3511 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3512   else
3513   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3514   for as_dir in $PATH
# Line 3097 | Line 3517 | do
3517    test -z "$as_dir" && as_dir=.
3518    for ac_exec_ext in '' $ac_executable_extensions; do
3519    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3520 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
3520 >    ac_cv_prog_AR="ar"
3521      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3522      break 2
3523    fi
3524   done
3525   done
3526  
3527 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3528   fi
3529   fi
3530 < F90=$ac_cv_prog_F90
3531 < if test -n "$F90"; then
3532 <  echo "$as_me:$LINENO: result: $F90" >&5
3533 < echo "${ECHO_T}$F90" >&6
3530 > AR=$ac_cv_prog_AR
3531 > if test -n "$AR"; then
3532 >  echo "$as_me:$LINENO: result: $AR" >&5
3533 > echo "${ECHO_T}$AR" >&6
3534   else
3535    echo "$as_me:$LINENO: result: no" >&5
3536   echo "${ECHO_T}no" >&6
3537   fi
3538  
3539 <    test -n "$F90" && break
3540 <  done
3539 > if test "$AR" = "NONE"; then
3540 >  cat >confcache <<\_ACEOF
3541 > # This file is a shell script that caches the results of configure
3542 > # tests run on this system so they can be shared between configure
3543 > # scripts and configure runs, see configure's option --config-cache.
3544 > # It is not useful on other systems.  If it contains results you don't
3545 > # want to keep, you may remove or edit it.
3546 > #
3547 > # config.status only pays attention to the cache file if you give it
3548 > # the --recheck option to rerun configure.
3549 > #
3550 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3551 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3552 > # following values.
3553 >
3554 > _ACEOF
3555 >
3556 > # The following way of writing the cache mishandles newlines in values,
3557 > # but we know of no workaround that is simple, portable, and efficient.
3558 > # So, don't put newlines in cache variables' values.
3559 > # Ultrix sh set writes to stderr and can't be redirected directly,
3560 > # and sets the high bit in the cache file unless we assign to the vars.
3561 > {
3562 >  (set) 2>&1 |
3563 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3564 >    *ac_space=\ *)
3565 >      # `set' does not quote correctly, so add quotes (double-quote
3566 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3567 >      sed -n \
3568 >        "s/'/'\\\\''/g;
3569 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3570 >      ;;
3571 >    *)
3572 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3573 >      sed -n \
3574 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3575 >      ;;
3576 >    esac;
3577 > } |
3578 >  sed '
3579 >     t clear
3580 >     : clear
3581 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3582 >     t end
3583 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3584 >     : end' >>confcache
3585 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3586 >  if test -w $cache_file; then
3587 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3588 >    cat confcache >$cache_file
3589 >  else
3590 >    echo "not updating unwritable cache $cache_file"
3591 >  fi
3592   fi
3593 < if test -z "$F90"; then
3594 <  ac_ct_F90=$F90
3595 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3596 < do
3597 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3126 < set dummy $ac_prog; ac_word=$2
3593 > rm -f confcache
3594 >  exit 1
3595 > fi
3596 > # Extract the first word of "ps", so it can be a program name with args.
3597 > set dummy ps; ac_word=$2
3598   echo "$as_me:$LINENO: checking for $ac_word" >&5
3599   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3600 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
3600 > if test "${ac_cv_path_PS+set}" = set; then
3601    echo $ECHO_N "(cached) $ECHO_C" >&6
3602   else
3603 <  if test -n "$ac_ct_F90"; then
3604 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3605 < else
3606 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3603 >  case $PS in
3604 >  [\\/]* | ?:[\\/]*)
3605 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3606 >  ;;
3607 >  *)
3608 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3609   for as_dir in $PATH
3610   do
3611    IFS=$as_save_IFS
3612    test -z "$as_dir" && as_dir=.
3613    for ac_exec_ext in '' $ac_executable_extensions; do
3614    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3615 <    ac_cv_prog_ac_ct_F90="$ac_prog"
3615 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3616      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3617      break 2
3618    fi
3619   done
3620   done
3621  
3622 +  ;;
3623 + esac
3624   fi
3625 < fi
3626 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3627 < if test -n "$ac_ct_F90"; then
3628 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3629 < echo "${ECHO_T}$ac_ct_F90" >&6
3625 > PS=$ac_cv_path_PS
3626 >
3627 > if test -n "$PS"; then
3628 >  echo "$as_me:$LINENO: result: $PS" >&5
3629 > echo "${ECHO_T}$PS" >&6
3630   else
3631    echo "$as_me:$LINENO: result: no" >&5
3632   echo "${ECHO_T}no" >&6
3633   fi
3634  
3635 <  test -n "$ac_ct_F90" && break
3636 < done
3635 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3636 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3637 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3638 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3639 > else
3640  
3641 <  F90=$ac_ct_F90
3641 >        if $PS ax -o rss > /dev/null 2>&1; then
3642 >                ac_cv_prog_ps_ax=yes
3643 >        else
3644 >                ac_cv_prog_ps_ax=no
3645 >        fi
3646 >        if $PS -ef -o rss > /dev/null 2>&1; then
3647 >                ac_cv_prog_ps_ef=yes
3648 >        else
3649 >                ac_cv_prog_ps_ef=no
3650 >        fi
3651 >        if test "$ac_cv_prog_ps_ax" = yes; then
3652 >                ac_cv_prog_ps_syntax=BSD
3653 >        else
3654 >                if test "$ac_cv_prog_ps_ef" = yes; then
3655 >                        ac_cv_prog_ps_syntax=POSIX
3656 >                else
3657 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3658 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3659 >   { (exit 1); exit 1; }; }
3660 >                fi
3661 >        fi
3662 >
3663   fi
3664 + echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3665 + echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3666  
3667 + cat >>confdefs.h <<_ACEOF
3668 + #define PSCOMMAND $PS
3669 + _ACEOF
3670  
3671 < # If we don't use `.F90' as extension, the preprocessor is not run on the
3168 < # input file.
3169 < ac_save_ext=$ac_ext
3170 < ac_ext=F90
3171 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3172 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
3173 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
3174 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3175 < else
3176 <  cat >conftest.$ac_ext <<_ACEOF
3671 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3672  
3673 < program main
3673 > cat >>confdefs.h <<\_ACEOF
3674 > #define PSTYPE_IS_BSD 1
3675 > _ACEOF
3676  
3677 < #ifndef __GNUC__
3678 <       choke me
3182 < #endif
3677 > else
3678 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3679  
3680 < end program main
3680 > cat >>confdefs.h <<\_ACEOF
3681 > #define PSTYPE_IS_POSIX 1
3682 > _ACEOF
3683 >
3684 >   else
3685 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3686 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3687 >   { (exit 1); exit 1; }; }
3688 >   fi
3689 > fi
3690  
3691 + ac_ext=${FC_SRCEXT-f}
3692 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3693 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3694 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3695 +
3696 +
3697 + echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3698 + echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3699 + if test "${ac_cv_fc_srcext_F90+set}" = set; then
3700 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3701 + else
3702 +  ac_ext=F90
3703 + ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3704 + FCFLAGS_SRCEXT=""
3705 + ac_cv_fc_srcext_F90=unknown
3706 + for ac_flag in none -qsuffix=f=F90 -Tf; do
3707 +  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3708 +  cat >conftest.$ac_ext <<_ACEOF
3709 +      program main
3710 +
3711 +      end
3712   _ACEOF
3713   rm -f conftest.$ac_objext
3714   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3193 | Line 3719 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3719    cat conftest.err >&5
3720    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3721    (exit $ac_status); } &&
3722 <         { ac_try='test -z "$ac_f90_werror_flag"
3722 >         { ac_try='test -z "$ac_fc_werror_flag"
3723                           || test ! -s conftest.err'
3724    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3725    (eval $ac_try) 2>&5
# Line 3206 | Line 3732 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3732    ac_status=$?
3733    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3734    (exit $ac_status); }; }; then
3735 <  ac_compiler_gnu=yes
3735 >  ac_cv_fc_srcext_F90=$ac_flag; break
3736   else
3737    echo "$as_me: failed program was:" >&5
3738   sed 's/^/| /' conftest.$ac_ext >&5
3739  
3214 ac_compiler_gnu=no
3740   fi
3741   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3742 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
3742 > done
3743 > rm -f conftest.$ac_objext conftest.F90
3744 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3745  
3746   fi
3747 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
3748 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
3749 < ac_ext=$ac_save_ext
3750 < G95=`test $ac_compiler_gnu = yes && echo yes`
3751 < ac_ext=c
3752 < ac_cpp='$CPP $CPPFLAGS'
3753 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3754 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3755 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3747 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3748 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3749 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3750 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3751 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3752 >   { (exit 1); exit 1; }; }
3753 > else
3754 >  FC_SRCEXT=F90
3755 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3756 >    FCFLAGS_SRCEXT=""
3757 >    FCFLAGS_F90=""
3758 >  else
3759 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3760 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3761 >  fi
3762  
3763  
3764 + fi
3765  
3766  
3767  
3768 +
3769 +
3770   # Try to determine native compiler flags that allow us to use F90 suffix
3771   # for preprocessed f90 source.
3772  
# Line 3238 | Line 3774 | if test "$ac_test_PREPFLAG" != "set"; then
3774    PREPFLAG=""
3775    case "${host_cpu}-${host_os}" in
3776  
3777 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3777 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3778                      PREPFLAG="-fpp1 "
3779                  fi;;
3780 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3780 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3781                      PREPFLAG="-qsuffix=cpp=F90 "
3782                  fi;;
3783    *darwin*)
3784 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3784 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3785                  PREPFLAG="-qsuffix=cpp=F90 "
3786          fi;;
3787    esac
# Line 3260 | Line 3796 | echo $ECHO_N "checking to make sure F90 preprocessor f
3796   echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3797  
3798  
3799 <  ac_ext=f90
3800 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3801 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3802 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3799 >  ac_ext=${FC_SRCEXT-f}
3800 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3801 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3802 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3803  
3804    ac_save_ext=$ac_ext
3805    ac_ext=F90
3806 <  ac_save_F90FLAGS=$F90FLAGS
3806 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3807  
3808    if test "$PREPFLAG"; then
3809 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3809 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3810   fi
3811  
3812      cat >conftest.$ac_ext <<_ACEOF
3813  
3814  
3815 < program main
3280 <
3815 > program conftest
3816    integer :: i
3817    i = 1
3818 + end program conftest
3819  
3284
3285 end program main
3286
3820   _ACEOF
3821   rm -f conftest.$ac_objext
3822   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3294 | Line 3827 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3827    cat conftest.err >&5
3828    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3829    (exit $ac_status); } &&
3830 <         { ac_try='test -z "$ac_f90_werror_flag"
3830 >         { ac_try='test -z "$ac_fc_werror_flag"
3831                           || test ! -s conftest.err'
3832    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3833    (eval $ac_try) 2>&5
# Line 3316 | Line 3849 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3849   fi
3850   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3851  
3852 <  F90FLAGS=$ac_save_F90FLAGS
3852 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3853    ac_ext=$ac_save_ext
3854 <  ac_ext=c
3855 < ac_cpp='$CPP $CPPFLAGS'
3856 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3857 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3325 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3854 >  ac_ext=${FC_SRCEXT-f}
3855 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3856 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3857 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3858  
3859  
3860    if test "$prepflagworks" = 1; then
3861      echo "$as_me:$LINENO: result: yes" >&5
3862   echo "${ECHO_T}yes" >&6
3863 +    FCFLAGS_SRCEXT="${PREPFLAG}"
3864  
3865    else
3866      echo "$as_me:$LINENO: result: no" >&5
# Line 3349 | Line 3882 | if test "$ac_test_PREPDEFFLAG" != "set"; then
3882    PREPDEFFLAG=""
3883    case "${host_cpu}-${host_os}" in
3884  
3885 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3885 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3886                      PREPDEFFLAG=" "
3887                  fi;;
3888 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3888 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3889                      PREPDEFFLAG="-WF,"
3890                  fi;;
3891    *darwin*)
3892 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3892 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3893                  PREPDEFFLAG="-WF,"
3894          fi;;
3895    esac
# Line 3371 | Line 3904 | echo $ECHO_N "checking to make sure F90 preprocessor d
3904   echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3905  
3906  
3907 <  ac_ext=f90
3908 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3909 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3910 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3907 >  ac_ext=${FC_SRCEXT-f}
3908 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3909 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3910 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3911  
3912    ac_save_ext=$ac_ext
3913    ac_ext=F90
3914 <  ac_save_F90FLAGS=$F90FLAGS
3914 >  ac_save_FCFLAGS=$FCFLAGS
3915  
3916    if test "$PREPDEFFLAG"; then
3917 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3917 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3918   fi
3919  
3920      cat >conftest.$ac_ext <<_ACEOF
3921  
3922  
3923 < program main
3391 <
3923 > program conftest
3924    integer :: i
3925   #ifdef TEST
3926    i = 1
3927   #else
3928    choke me
3929   #endif
3930 + end program conftest
3931  
3399
3400 end program main
3401
3932   _ACEOF
3933   rm -f conftest.$ac_objext
3934   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3409 | Line 3939 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3939    cat conftest.err >&5
3940    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3941    (exit $ac_status); } &&
3942 <         { ac_try='test -z "$ac_f90_werror_flag"
3942 >         { ac_try='test -z "$ac_fc_werror_flag"
3943                           || test ! -s conftest.err'
3944    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3945    (eval $ac_try) 2>&5
# Line 3431 | Line 3961 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3961   fi
3962   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3963  
3964 <  F90FLAGS=$ac_save_F90FLAGS
3964 >  FCFLAGS=$ac_save_FCFLAGS
3965    ac_ext=$ac_save_ext
3966 <  ac_ext=c
3967 < ac_cpp='$CPP $CPPFLAGS'
3968 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3969 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3440 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3966 >  ac_ext=${FC_SRCEXT-f}
3967 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3968 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3969 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3970  
3971  
3443
3972    if test "$prepdefflagworks" = 1; then
3973      echo "$as_me:$LINENO: result: yes" >&5
3974   echo "${ECHO_T}yes" >&6
# Line 3454 | Line 3982 | ac_ext=f90
3982    fi
3983   fi
3984  
3985 < ac_ext=f90
3986 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3987 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3988 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3989 <
3990 <
3991 <
3464 < ac_ext=f90
3465 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3466 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3467 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3468 < echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3469 < echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3470 < if test "${ac_cv_prog_f90_v+set}" = set; then
3985 > ac_ext=${FC_SRCEXT-f}
3986 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3987 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3988 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3989 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
3990 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
3991 > if test "${ac_cv_prog_fc_v+set}" = set; then
3992    echo $ECHO_N "(cached) $ECHO_C" >&6
3993   else
3994 +  cat >conftest.$ac_ext <<_ACEOF
3995 +      program main
3996  
3997 < cat >conftest.$ac_ext <<_ACEOF
3475 <
3476 < program main
3477 <
3478 <
3479 < end program main
3480 <
3997 >      end
3998   _ACEOF
3999   rm -f conftest.$ac_objext
4000   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3488 | Line 4005 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4005    cat conftest.err >&5
4006    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4007    (exit $ac_status); } &&
4008 <         { ac_try='test -z "$ac_f90_werror_flag"
4008 >         { ac_try='test -z "$ac_fc_werror_flag"
4009                           || test ! -s conftest.err'
4010    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4011    (eval $ac_try) 2>&5
# Line 3501 | Line 4018 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4018    ac_status=$?
4019    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4020    (exit $ac_status); }; }; then
4021 <  ac_cv_prog_f90_v=
4021 >  ac_cv_prog_fc_v=
4022   # Try some options frequently used verbose output
4023   for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4024 <  ac_ext=f90
4025 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3509 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3510 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4024 >  cat >conftest.$ac_ext <<_ACEOF
4025 >      program main
4026  
4027 < cat >conftest.$ac_ext <<_ACEOF
3513 <
3514 < program main
3515 <
3516 <
3517 < end program main
3518 <
4027 >      end
4028   _ACEOF
4029  
4030   # Compile and link our simple test program by passing a flag (argument
4031 < # 1 to this macro) to the Fortran 90 compiler in order to get
4032 < # "verbose" output that we can then parse for the Fortran 90 linker
4031 > # 1 to this macro) to the Fortran compiler in order to get
4032 > # "verbose" output that we can then parse for the Fortran linker
4033   # flags.
4034 < ac_save_F90FLAGS=$F90FLAGS
4035 < F90FLAGS="$F90FLAGS $ac_verb"
4034 > ac_save_FFLAGS=$FCFLAGS
4035 > FCFLAGS="$FCFLAGS $ac_verb"
4036 > (eval echo $as_me:4036: \"$ac_link\") >&5
4037 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4038 > echo "$ac_fc_v_output" >&5
4039 > FCFLAGS=$ac_save_FFLAGS
4040  
4041 < (eval echo $as_me:3528: \"$ac_link\") >&5
3529 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3530 < echo "$ac_f90_v_output" >&5
3531 < F90FLAGS=$ac_save_F90FLAGS
4041 > rm -f conftest*
4042  
4043 < rm -f conftest.*
4044 < ac_ext=f90
4045 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4046 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4047 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4043 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4044 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4045 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4046 > ac_fc_v_output="`echo $ac_fc_v_output |
4047 >        grep 'LPATH is:' |
4048 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4049  
4050 < # If we are using xlf then replace all the commas with spaces.
4051 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4052 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4053 < fi
4050 > case $ac_fc_v_output in
4051 >  # If we are using xlf then replace all the commas with spaces.
4052 >  *xlfentry*)
4053 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4054  
4055 < # If we are using Cray Fortran then delete quotes.
4056 < # Use "\"" instead of '"' for font-lock-mode.
4057 < # FIXME: a more general fix for quoted arguments with spaces?
4058 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4059 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4060 < fi
4055 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4056 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4057 >  *mGLOB_options_string*)
4058 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4059 >
4060 >  # If we are using Cray Fortran then delete quotes.
4061 >  # Use "\"" instead of '"' for font-lock-mode.
4062 >  # FIXME: a more general fix for quoted arguments with spaces?
4063 >  *cft90*)
4064 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4065 > esac
4066 >
4067 >
4068    # look for -l* and *.a constructs in the output
4069 <  for ac_arg in $ac_f90_v_output; do
4069 >  for ac_arg in $ac_fc_v_output; do
4070       case $ac_arg in
4071          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4072 <          ac_cv_prog_f90_v=$ac_verb
4072 >          ac_cv_prog_fc_v=$ac_verb
4073            break 2 ;;
4074       esac
4075    done
4076   done
4077 < if test -z "$ac_cv_prog_f90_v"; then
4078 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4079 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
4077 > if test -z "$ac_cv_prog_fc_v"; then
4078 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4079 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4080   fi
4081   else
4082    echo "$as_me: failed program was:" >&5
# Line 3570 | Line 4088 | echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4088   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4089  
4090   fi
4091 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4092 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4093 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4094 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4095 < if test "${ac_cv_flibs+set}" = set; then
4091 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4092 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4093 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4094 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4095 > if test "${ac_cv_fc_libs+set}" = set; then
4096    echo $ECHO_N "(cached) $ECHO_C" >&6
4097   else
4098 <  if test "x$F90LIBS" != "x"; then
4099 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4098 >  if test "x$FCLIBS" != "x"; then
4099 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4100   else
4101  
3584 ac_ext=f90
3585 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3586 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3587 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3588
4102   cat >conftest.$ac_ext <<_ACEOF
4103 +      program main
4104  
4105 < program main
3592 <
3593 <
3594 < end program main
3595 <
4105 >      end
4106   _ACEOF
4107  
4108   # Compile and link our simple test program by passing a flag (argument
4109 < # 1 to this macro) to the Fortran 90 compiler in order to get
4110 < # "verbose" output that we can then parse for the Fortran 90 linker
4109 > # 1 to this macro) to the Fortran compiler in order to get
4110 > # "verbose" output that we can then parse for the Fortran linker
4111   # flags.
4112 < ac_save_F90FLAGS=$F90FLAGS
4113 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
4112 > ac_save_FFLAGS=$FCFLAGS
4113 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4114 > (eval echo $as_me:4114: \"$ac_link\") >&5
4115 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4116 > echo "$ac_fc_v_output" >&5
4117 > FCFLAGS=$ac_save_FFLAGS
4118  
4119 < (eval echo $as_me:3605: \"$ac_link\") >&5
3606 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3607 < echo "$ac_f90_v_output" >&5
3608 < F90FLAGS=$ac_save_F90FLAGS
4119 > rm -f conftest*
4120  
4121 < rm -f conftest.*
4122 < ac_ext=f90
4123 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4124 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4125 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4121 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4122 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4123 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4124 > ac_fc_v_output="`echo $ac_fc_v_output |
4125 >        grep 'LPATH is:' |
4126 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4127  
4128 < # If we are using xlf then replace all the commas with spaces.
4129 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4130 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4131 < fi
4128 > case $ac_fc_v_output in
4129 >  # If we are using xlf then replace all the commas with spaces.
4130 >  *xlfentry*)
4131 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4132  
4133 < # If we are using Cray Fortran then delete quotes.
4134 < # Use "\"" instead of '"' for font-lock-mode.
4135 < # FIXME: a more general fix for quoted arguments with spaces?
4136 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3625 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3626 < fi
4133 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4134 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4135 >  *mGLOB_options_string*)
4136 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4137  
4138 < ac_cv_f90libs=
4138 >  # If we are using Cray Fortran then delete quotes.
4139 >  # Use "\"" instead of '"' for font-lock-mode.
4140 >  # FIXME: a more general fix for quoted arguments with spaces?
4141 >  *cft90*)
4142 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4143 > esac
4144  
4145 +
4146 +
4147 + ac_cv_fc_libs=
4148 +
4149   # Save positional arguments (if any)
4150   ac_save_positional="$@"
4151  
4152 < set X $ac_f90_v_output
4152 > set X $ac_fc_v_output
4153   while test $# != 1; do
4154    shift
4155    ac_arg=$1
4156    case $ac_arg in
4157          [\\/]*.a | ?:[\\/]*.a)
4158              ac_exists=false
4159 <  for ac_i in $ac_cv_f90libs; do
4159 >  for ac_i in $ac_cv_fc_libs; do
4160      if test x"$ac_arg" = x"$ac_i"; then
4161        ac_exists=true
4162        break
# Line 3647 | Line 4166 | else
4166    if test x"$ac_exists" = xtrue; then
4167    :
4168   else
4169 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4169 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4170   fi
4171  
4172            ;;
4173          -bI:*)
4174              ac_exists=false
4175 <  for ac_i in $ac_cv_f90libs; do
4175 >  for ac_i in $ac_cv_fc_libs; do
4176      if test x"$ac_arg" = x"$ac_i"; then
4177        ac_exists=true
4178        break
# Line 3665 | Line 4184 | else
4184   else
4185    if test "$ac_compiler_gnu" = yes; then
4186    for ac_link_opt in $ac_arg; do
4187 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4187 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4188    done
4189   else
4190 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4190 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4191   fi
4192   fi
4193  
4194            ;;
4195            # Ignore these flags.
4196 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4196 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4197            ;;
4198          -lkernel32)
4199 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4199 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4200            ;;
4201          -[LRuY])
4202            # These flags, when seen by themselves, take an argument.
4203            # We remove the space between option and argument and re-iterate
4204            # unless we find an empty arg or a new option (starting with -)
4205            case $2 in
4206 <             "" | -*);;
4207 <             *)
4206 >             "" | -*);;
4207 >             *)
4208                  ac_arg="$ac_arg$2"
3690
4209                  shift; shift
4210                  set X $ac_arg "$@"
4211                  ;;
# Line 3696 | Line 4214 | fi
4214          -YP,*)
4215            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4216                ac_exists=false
4217 <  for ac_i in $ac_cv_f90libs; do
4217 >  for ac_i in $ac_cv_fc_libs; do
4218      if test x"$ac_j" = x"$ac_i"; then
4219        ac_exists=true
4220        break
# Line 3707 | Line 4225 | else
4225    :
4226   else
4227    ac_arg="$ac_arg $ac_j"
4228 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4228 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4229   fi
4230  
4231            done
4232            ;;
4233          -[lLR]*)
4234              ac_exists=false
4235 <  for ac_i in $ac_cv_f90libs; do
4235 >  for ac_i in $ac_cv_fc_libs; do
4236      if test x"$ac_arg" = x"$ac_i"; then
4237        ac_exists=true
4238        break
# Line 3724 | Line 4242 | else
4242    if test x"$ac_exists" = xtrue; then
4243    :
4244   else
4245 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4245 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4246   fi
4247  
4248            ;;
# Line 3739 | Line 4257 | case `(uname -sr) 2>/dev/null` in
4257   # must begin with a "/").
4258   case `(uname -sr) 2>/dev/null` in
4259     "SunOS 5"*)
4260 <      ac_ld_run_path=`echo $ac_f90_v_output |
4260 >      ac_ld_run_path=`echo $ac_fc_v_output |
4261                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4262        test "x$ac_ld_run_path" != x &&
3745
4263          if test "$ac_compiler_gnu" = yes; then
4264    for ac_link_opt in $ac_ld_run_path; do
4265 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4265 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4266    done
4267   else
4268 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4268 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4269   fi
4270        ;;
4271   esac
4272 < fi # test "x$F90LIBS" = "x"
4272 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4273  
4274   fi
4275 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4276 < echo "${ECHO_T}$ac_cv_flibs" >&6
4277 < F90LIBS="$ac_cv_f90libs"
4275 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4276 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4277 > FCLIBS="$ac_cv_fc_libs"
4278  
4279 < ac_ext=f90
4280 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4281 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4282 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4279 >
4280 > ac_ext=${FC_SRCEXT-f}
4281 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4282 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4283 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4284  
4285  
4286 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4287 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4288 < if test "${ac_cv_f90_mangling+set}" = set; then
4286 > ac_ext=${FC_SRCEXT-f}
4287 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4288 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4289 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4290 >
4291 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4292 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4293 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4294    echo $ECHO_N "(cached) $ECHO_C" >&6
4295   else
4296 <  ac_ext=f90
4297 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4298 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4299 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4300 < cat >conftest.$ac_ext <<_ACEOF
4301 < subroutine foobar()
4302 < return
4303 < end
4304 < subroutine foo_bar()
4305 < return
4306 < end
4296 >  ac_fc_dm_save_LIBS=$LIBS
4297 > LIBS="$LIBS $FCLIBS"
4298 > ac_fortran_dm_var=FC_DUMMY_MAIN
4299 > ac_ext=c
4300 > ac_cpp='$CPP $CPPFLAGS'
4301 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4302 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4303 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4304 >
4305 > # First, try linking without a dummy main:
4306 > cat >conftest.$ac_ext <<_ACEOF
4307 > /* confdefs.h.  */
4308   _ACEOF
4309 + cat confdefs.h >>conftest.$ac_ext
4310 + cat >>conftest.$ac_ext <<_ACEOF
4311 + /* end confdefs.h.  */
4312 +
4313 + #ifdef FC_DUMMY_MAIN
4314 + #ifndef FC_DUMMY_MAIN_EQ_F77
4315 + #  ifdef __cplusplus
4316 +     extern "C"
4317 + #  endif
4318 +   int FC_DUMMY_MAIN() { return 1; }
4319 + #endif
4320 + #endif
4321 + int
4322 + main ()
4323 + {
4324 +
4325 +  ;
4326 +  return 0;
4327 + }
4328 + _ACEOF
4329 + rm -f conftest.$ac_objext conftest$ac_exeext
4330 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4331 +  (eval $ac_link) 2>conftest.er1
4332 +  ac_status=$?
4333 +  grep -v '^ *+' conftest.er1 >conftest.err
4334 +  rm -f conftest.er1
4335 +  cat conftest.err >&5
4336 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4337 +  (exit $ac_status); } &&
4338 +         { ac_try='test -z "$ac_c_werror_flag"
4339 +                         || test ! -s conftest.err'
4340 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4341 +  (eval $ac_try) 2>&5
4342 +  ac_status=$?
4343 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4344 +  (exit $ac_status); }; } &&
4345 +         { ac_try='test -s conftest$ac_exeext'
4346 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4347 +  (eval $ac_try) 2>&5
4348 +  ac_status=$?
4349 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4350 +  (exit $ac_status); }; }; then
4351 +  ac_cv_fortran_dummy_main=none
4352 + else
4353 +  echo "$as_me: failed program was:" >&5
4354 + sed 's/^/| /' conftest.$ac_ext >&5
4355 +
4356 + ac_cv_fortran_dummy_main=unknown
4357 + fi
4358 + rm -f conftest.err conftest.$ac_objext \
4359 +      conftest$ac_exeext conftest.$ac_ext
4360 +
4361 + if test $ac_cv_fortran_dummy_main = unknown; then
4362 +   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4363 +     cat >conftest.$ac_ext <<_ACEOF
4364 + /* confdefs.h.  */
4365 + _ACEOF
4366 + cat confdefs.h >>conftest.$ac_ext
4367 + cat >>conftest.$ac_ext <<_ACEOF
4368 + /* end confdefs.h.  */
4369 + #define $ac_fortran_dm_var $ac_func
4370 + #ifdef FC_DUMMY_MAIN
4371 + #ifndef FC_DUMMY_MAIN_EQ_F77
4372 + #  ifdef __cplusplus
4373 +     extern "C"
4374 + #  endif
4375 +   int FC_DUMMY_MAIN() { return 1; }
4376 + #endif
4377 + #endif
4378 + int
4379 + main ()
4380 + {
4381 +
4382 +  ;
4383 +  return 0;
4384 + }
4385 + _ACEOF
4386 + rm -f conftest.$ac_objext conftest$ac_exeext
4387 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4388 +  (eval $ac_link) 2>conftest.er1
4389 +  ac_status=$?
4390 +  grep -v '^ *+' conftest.er1 >conftest.err
4391 +  rm -f conftest.er1
4392 +  cat conftest.err >&5
4393 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4394 +  (exit $ac_status); } &&
4395 +         { ac_try='test -z "$ac_c_werror_flag"
4396 +                         || test ! -s conftest.err'
4397 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4398 +  (eval $ac_try) 2>&5
4399 +  ac_status=$?
4400 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4401 +  (exit $ac_status); }; } &&
4402 +         { ac_try='test -s conftest$ac_exeext'
4403 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4404 +  (eval $ac_try) 2>&5
4405 +  ac_status=$?
4406 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4407 +  (exit $ac_status); }; }; then
4408 +  ac_cv_fortran_dummy_main=$ac_func; break
4409 + else
4410 +  echo "$as_me: failed program was:" >&5
4411 + sed 's/^/| /' conftest.$ac_ext >&5
4412 +
4413 + fi
4414 + rm -f conftest.err conftest.$ac_objext \
4415 +      conftest$ac_exeext conftest.$ac_ext
4416 +   done
4417 + fi
4418 + ac_ext=${FC_SRCEXT-f}
4419 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4420 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4421 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4422 + ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4423 + rm -f conftest*
4424 + LIBS=$ac_fc_dm_save_LIBS
4425 +
4426 + fi
4427 + echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4428 + echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4429 + FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4430 + if test "$FC_DUMMY_MAIN" != unknown; then
4431 +  if test $FC_DUMMY_MAIN != none; then
4432 +
4433 + cat >>confdefs.h <<_ACEOF
4434 + #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4435 + _ACEOF
4436 +
4437 +  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4438 +
4439 + cat >>confdefs.h <<\_ACEOF
4440 + #define FC_DUMMY_MAIN_EQ_F77 1
4441 + _ACEOF
4442 +
4443 +  fi
4444 + fi
4445 + else
4446 +  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4447 + See \`config.log' for more details." >&5
4448 + echo "$as_me: error: linking to Fortran libraries from C fails
4449 + See \`config.log' for more details." >&2;}
4450 +   { (exit 1); exit 1; }; }
4451 + fi
4452 +
4453 +
4454 + ac_ext=${FC_SRCEXT-f}
4455 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4456 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4457 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4458 +
4459 + ac_ext=${FC_SRCEXT-f}
4460 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4461 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4462 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4463 + echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4464 + echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4465 + if test "${ac_cv_fc_mangling+set}" = set; then
4466 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4467 + else
4468 +  cat >conftest.$ac_ext <<_ACEOF
4469 +      subroutine foobar()
4470 +      return
4471 +      end
4472 +      subroutine foo_bar()
4473 +      return
4474 +      end
4475 + _ACEOF
4476   rm -f conftest.$ac_objext
4477   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4478    (eval $ac_compile) 2>conftest.er1
# Line 3791 | Line 4482 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4482    cat conftest.err >&5
4483    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4484    (exit $ac_status); } &&
4485 <         { ac_try='test -z "$ac_f90_werror_flag"
4485 >         { ac_try='test -z "$ac_fc_werror_flag"
4486                           || test ! -s conftest.err'
4487    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4488    (eval $ac_try) 2>&5
# Line 3804 | Line 4495 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4495    ac_status=$?
4496    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4497    (exit $ac_status); }; }; then
4498 <  mv conftest.$ac_objext cf90_test.$ac_objext
4498 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4499  
4500 +  ac_save_LIBS=$LIBS
4501 +  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4502 +
4503    ac_ext=c
4504   ac_cpp='$CPP $CPPFLAGS'
4505   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4506   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4507   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3814
3815  ac_save_LIBS=$LIBS
3816  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
3817
4508    ac_success=no
4509    for ac_foobar in foobar FOOBAR; do
4510      for ac_underscore in "" "_"; do
# Line 3833 | Line 4523 | int
4523   /* We use char because int might match the return type of a gcc2
4524     builtin and then its argument prototype would still apply.  */
4525   char $ac_func ();
4526 + #ifdef FC_DUMMY_MAIN
4527 + #ifndef FC_DUMMY_MAIN_EQ_F77
4528 + #  ifdef __cplusplus
4529 +     extern "C"
4530 + #  endif
4531 +   int FC_DUMMY_MAIN() { return 1; }
4532 + #endif
4533 + #endif
4534   int
4535   main ()
4536   {
# Line 3873 | Line 4571 | rm -f conftest.err conftest.$ac_objext \
4571        conftest$ac_exeext conftest.$ac_ext
4572      done
4573    done
4574 +  ac_ext=${FC_SRCEXT-f}
4575 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4576 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4577 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4578  
4579    if test "$ac_success" = "yes"; then
4580       case $ac_foobar in
4581 <        foobar)
4582 <           ac_case=lower
4583 <           ac_foo_bar=foo_bar
4584 <           ;;
4585 <        FOOBAR)
4586 <           ac_case=upper
4587 <           ac_foo_bar=FOO_BAR
4588 <           ;;
4581 >        foobar)
4582 >           ac_case=lower
4583 >           ac_foo_bar=foo_bar
4584 >           ;;
4585 >        FOOBAR)
4586 >           ac_case=upper
4587 >           ac_foo_bar=FOO_BAR
4588 >           ;;
4589       esac
4590  
4591 +     ac_ext=c
4592 + ac_cpp='$CPP $CPPFLAGS'
4593 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4594 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4595 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
4596       ac_success_extra=no
4597       for ac_extra in "" "_"; do
4598 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4599 <
3893 <        cat >conftest.$ac_ext <<_ACEOF
4598 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4599 >        cat >conftest.$ac_ext <<_ACEOF
4600   /* confdefs.h.  */
4601   _ACEOF
4602   cat confdefs.h >>conftest.$ac_ext
# Line 3904 | Line 4610 | int
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   {
# Line 3943 | Line 4657 | rm -f conftest.err conftest.$ac_objext \
4657   rm -f conftest.err conftest.$ac_objext \
4658        conftest$ac_exeext conftest.$ac_ext
4659       done
4660 +     ac_ext=${FC_SRCEXT-f}
4661 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4662 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4663 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4664  
4665       if test "$ac_success_extra" = "yes"; then
4666 <        ac_cv_f90_mangling="$ac_case case"
4666 >        ac_cv_fc_mangling="$ac_case case"
4667          if test -z "$ac_underscore"; then
4668 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4668 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4669          else
4670 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
3953 <
4670 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4671          fi
4672          if test -z "$ac_extra"; then
4673 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4673 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4674          else
4675 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4675 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4676          fi
4677        else
4678 <        ac_cv_f90_mangling="unknown"
4678 >        ac_cv_fc_mangling="unknown"
4679        fi
4680    else
4681 <     ac_cv_f90_mangling="unknown"
3965 <
4681 >     ac_cv_fc_mangling="unknown"
4682    fi
4683  
4684    LIBS=$ac_save_LIBS
4685 <  ac_ext=f90
3970 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3971 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3972 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3973 <  rm -f cf90_test* conftest*
4685 >  rm -f cfortran_test* conftest*
4686   else
4687    echo "$as_me: failed program was:" >&5
4688   sed 's/^/| /' conftest.$ac_ext >&5
4689  
4690 + { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4691 + See \`config.log' for more details." >&5
4692 + echo "$as_me: error: cannot compile a simple Fortran program
4693 + See \`config.log' for more details." >&2;}
4694 +   { (exit 1); exit 1; }; }
4695   fi
4696   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3980 ac_ext=f90
3981 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3982 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3983 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4697  
4698   fi
4699 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4700 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4699 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4700 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4701  
4702 + ac_ext=${FC_SRCEXT-f}
4703 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4704 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4705 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4706  
4707 + ac_ext=${FC_SRCEXT-f}
4708 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4709 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4710 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4711  
4712 < case $ac_cv_f90_mangling in
4712 >
4713 > case $ac_cv_fc_mangling in
4714    "lower case, no underscore, no extra underscore")
4715            cat >>confdefs.h <<\_ACEOF
4716 < #define F90_FUNC(name,NAME) name
4716 > #define FC_FUNC(name,NAME) name
4717   _ACEOF
4718  
4719            cat >>confdefs.h <<\_ACEOF
4720 < #define F90_FUNC_(name,NAME) name
4720 > #define FC_FUNC_(name,NAME) name
4721   _ACEOF
4722   ;;
4723    "lower case, no underscore, extra underscore")
4724            cat >>confdefs.h <<\_ACEOF
4725 < #define F90_FUNC(name,NAME) name
4725 > #define FC_FUNC(name,NAME) name
4726   _ACEOF
4727  
4728            cat >>confdefs.h <<\_ACEOF
4729 < #define F90_FUNC_(name,NAME) name ## _
4729 > #define FC_FUNC_(name,NAME) name ## _
4730   _ACEOF
4731   ;;
4732    "lower case, underscore, no extra underscore")
4733            cat >>confdefs.h <<\_ACEOF
4734 < #define F90_FUNC(name,NAME) name ## _
4734 > #define FC_FUNC(name,NAME) name ## _
4735   _ACEOF
4736  
4737            cat >>confdefs.h <<\_ACEOF
4738 < #define F90_FUNC_(name,NAME) name ## _
4738 > #define FC_FUNC_(name,NAME) name ## _
4739   _ACEOF
4740   ;;
4741    "lower case, underscore, extra underscore")
4742            cat >>confdefs.h <<\_ACEOF
4743 < #define F90_FUNC(name,NAME) name ## _
4743 > #define FC_FUNC(name,NAME) name ## _
4744   _ACEOF
4745  
4746            cat >>confdefs.h <<\_ACEOF
4747 < #define F90_FUNC_(name,NAME) name ## __
4747 > #define FC_FUNC_(name,NAME) name ## __
4748   _ACEOF
4749   ;;
4750    "upper case, no underscore, no extra underscore")
4751            cat >>confdefs.h <<\_ACEOF
4752 < #define F90_FUNC(name,NAME) NAME
4752 > #define FC_FUNC(name,NAME) NAME
4753   _ACEOF
4754  
4755            cat >>confdefs.h <<\_ACEOF
4756 < #define F90_FUNC_(name,NAME) NAME
4756 > #define FC_FUNC_(name,NAME) NAME
4757   _ACEOF
4758   ;;
4759    "upper case, no underscore, extra underscore")
4760            cat >>confdefs.h <<\_ACEOF
4761 < #define F90_FUNC(name,NAME) NAME
4761 > #define FC_FUNC(name,NAME) NAME
4762   _ACEOF
4763  
4764            cat >>confdefs.h <<\_ACEOF
4765 < #define F90_FUNC_(name,NAME) NAME ## _
4765 > #define FC_FUNC_(name,NAME) NAME ## _
4766   _ACEOF
4767   ;;
4768    "upper case, underscore, no extra underscore")
4769            cat >>confdefs.h <<\_ACEOF
4770 < #define F90_FUNC(name,NAME) NAME ## _
4770 > #define FC_FUNC(name,NAME) NAME ## _
4771   _ACEOF
4772  
4773            cat >>confdefs.h <<\_ACEOF
4774 < #define F90_FUNC_(name,NAME) NAME ## _
4774 > #define FC_FUNC_(name,NAME) NAME ## _
4775   _ACEOF
4776   ;;
4777    "upper case, underscore, extra underscore")
4778            cat >>confdefs.h <<\_ACEOF
4779 < #define F90_FUNC(name,NAME) NAME ## _
4779 > #define FC_FUNC(name,NAME) NAME ## _
4780   _ACEOF
4781  
4782            cat >>confdefs.h <<\_ACEOF
4783 < #define F90_FUNC_(name,NAME) NAME ## __
4783 > #define FC_FUNC_(name,NAME) NAME ## __
4784   _ACEOF
4785   ;;
4786    *)
4787 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4788 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4787 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4788 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4789            ;;
4790   esac
4791  
4792 + ac_ext=${FC_SRCEXT-f}
4793 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4794 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4795 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4796  
4797  
4798  
4799 + ac_ext=${FC_SRCEXT-f}
4800 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4801 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4802 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4803 + echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4804 + echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4805 + if test "${ac_cv_prog_fc_v+set}" = set; then
4806 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4807 + else
4808 +  cat >conftest.$ac_ext <<_ACEOF
4809 +      program main
4810  
4811 +      end
4812 + _ACEOF
4813 + rm -f conftest.$ac_objext
4814 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4815 +  (eval $ac_compile) 2>conftest.er1
4816 +  ac_status=$?
4817 +  grep -v '^ *+' conftest.er1 >conftest.err
4818 +  rm -f conftest.er1
4819 +  cat conftest.err >&5
4820 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4821 +  (exit $ac_status); } &&
4822 +         { ac_try='test -z "$ac_fc_werror_flag"
4823 +                         || test ! -s conftest.err'
4824 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4825 +  (eval $ac_try) 2>&5
4826 +  ac_status=$?
4827 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4828 +  (exit $ac_status); }; } &&
4829 +         { ac_try='test -s conftest.$ac_objext'
4830 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4831 +  (eval $ac_try) 2>&5
4832 +  ac_status=$?
4833 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4834 +  (exit $ac_status); }; }; then
4835 +  ac_cv_prog_fc_v=
4836 + # Try some options frequently used verbose output
4837 + for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4838 +  cat >conftest.$ac_ext <<_ACEOF
4839 +      program main
4840 +
4841 +      end
4842 + _ACEOF
4843 +
4844 + # Compile and link our simple test program by passing a flag (argument
4845 + # 1 to this macro) to the Fortran compiler in order to get
4846 + # "verbose" output that we can then parse for the Fortran linker
4847 + # flags.
4848 + ac_save_FFLAGS=$FCFLAGS
4849 + FCFLAGS="$FCFLAGS $ac_verb"
4850 + (eval echo $as_me:4850: \"$ac_link\") >&5
4851 + ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4852 + echo "$ac_fc_v_output" >&5
4853 + FCFLAGS=$ac_save_FFLAGS
4854 +
4855 + rm -f conftest*
4856 +
4857 + # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4858 + # /foo, /bar, and /baz are search directories for the Fortran linker.
4859 + # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4860 + ac_fc_v_output="`echo $ac_fc_v_output |
4861 +        grep 'LPATH is:' |
4862 +        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4863 +
4864 + case $ac_fc_v_output in
4865 +  # If we are using xlf then replace all the commas with spaces.
4866 +  *xlfentry*)
4867 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4868 +
4869 +  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4870 +  # $LIBS confuse us, and the libraries appear later in the output anyway).
4871 +  *mGLOB_options_string*)
4872 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4873 +
4874 +  # If we are using Cray Fortran then delete quotes.
4875 +  # Use "\"" instead of '"' for font-lock-mode.
4876 +  # FIXME: a more general fix for quoted arguments with spaces?
4877 +  *cft90*)
4878 +    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4879 + esac
4880 +
4881 +
4882 +  # look for -l* and *.a constructs in the output
4883 +  for ac_arg in $ac_fc_v_output; do
4884 +     case $ac_arg in
4885 +        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4886 +          ac_cv_prog_fc_v=$ac_verb
4887 +          break 2 ;;
4888 +     esac
4889 +  done
4890 + done
4891 + if test -z "$ac_cv_prog_fc_v"; then
4892 +   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4893 + echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4894 + fi
4895 + else
4896 +  echo "$as_me: failed program was:" >&5
4897 + sed 's/^/| /' conftest.$ac_ext >&5
4898 +
4899 + { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4900 + echo "$as_me: WARNING: compilation failed" >&2;}
4901 + fi
4902 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4903 +
4904 + fi
4905 + echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4906 + echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4907 + echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4908 + echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4909 + if test "${ac_cv_fc_libs+set}" = set; then
4910 +  echo $ECHO_N "(cached) $ECHO_C" >&6
4911 + else
4912 +  if test "x$FCLIBS" != "x"; then
4913 +  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4914 + else
4915 +
4916 + cat >conftest.$ac_ext <<_ACEOF
4917 +      program main
4918 +
4919 +      end
4920 + _ACEOF
4921 +
4922 + # Compile and link our simple test program by passing a flag (argument
4923 + # 1 to this macro) to the Fortran compiler in order to get
4924 + # "verbose" output that we can then parse for the Fortran linker
4925 + # flags.
4926 + ac_save_FFLAGS=$FCFLAGS
4927 + FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4928 + (eval echo $as_me:4928: \"$ac_link\") >&5
4929 + ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4930 + echo "$ac_fc_v_output" >&5
4931 + FCFLAGS=$ac_save_FFLAGS
4932 +
4933 + rm -f conftest*
4934 +
4935 + # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4936 + # /foo, /bar, and /baz are search directories for the Fortran linker.
4937 + # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4938 + ac_fc_v_output="`echo $ac_fc_v_output |
4939 +        grep 'LPATH is:' |
4940 +        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4941 +
4942 + case $ac_fc_v_output in
4943 +  # If we are using xlf then replace all the commas with spaces.
4944 +  *xlfentry*)
4945 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4946 +
4947 +  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4948 +  # $LIBS confuse us, and the libraries appear later in the output anyway).
4949 +  *mGLOB_options_string*)
4950 +    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4951 +
4952 +  # If we are using Cray Fortran then delete quotes.
4953 +  # Use "\"" instead of '"' for font-lock-mode.
4954 +  # FIXME: a more general fix for quoted arguments with spaces?
4955 +  *cft90*)
4956 +    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4957 + esac
4958 +
4959 +
4960 +
4961 + ac_cv_fc_libs=
4962 +
4963 + # Save positional arguments (if any)
4964 + ac_save_positional="$@"
4965 +
4966 + set X $ac_fc_v_output
4967 + while test $# != 1; do
4968 +  shift
4969 +  ac_arg=$1
4970 +  case $ac_arg in
4971 +        [\\/]*.a | ?:[\\/]*.a)
4972 +            ac_exists=false
4973 +  for ac_i in $ac_cv_fc_libs; do
4974 +    if test x"$ac_arg" = x"$ac_i"; then
4975 +      ac_exists=true
4976 +      break
4977 +    fi
4978 +  done
4979 +
4980 +  if test x"$ac_exists" = xtrue; then
4981 +  :
4982 + else
4983 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4984 + fi
4985 +
4986 +          ;;
4987 +        -bI:*)
4988 +            ac_exists=false
4989 +  for ac_i in $ac_cv_fc_libs; do
4990 +    if test x"$ac_arg" = x"$ac_i"; then
4991 +      ac_exists=true
4992 +      break
4993 +    fi
4994 +  done
4995 +
4996 +  if test x"$ac_exists" = xtrue; then
4997 +  :
4998 + else
4999 +  if test "$ac_compiler_gnu" = yes; then
5000 +  for ac_link_opt in $ac_arg; do
5001 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5002 +  done
5003 + else
5004 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5005 + fi
5006 + fi
5007 +
5008 +          ;;
5009 +          # Ignore these flags.
5010 +        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5011 +          ;;
5012 +        -lkernel32)
5013 +          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5014 +          ;;
5015 +        -[LRuY])
5016 +          # These flags, when seen by themselves, take an argument.
5017 +          # We remove the space between option and argument and re-iterate
5018 +          # unless we find an empty arg or a new option (starting with -)
5019 +          case $2 in
5020 +             "" | -*);;
5021 +             *)
5022 +                ac_arg="$ac_arg$2"
5023 +                shift; shift
5024 +                set X $ac_arg "$@"
5025 +                ;;
5026 +          esac
5027 +          ;;
5028 +        -YP,*)
5029 +          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5030 +              ac_exists=false
5031 +  for ac_i in $ac_cv_fc_libs; do
5032 +    if test x"$ac_j" = x"$ac_i"; then
5033 +      ac_exists=true
5034 +      break
5035 +    fi
5036 +  done
5037 +
5038 +  if test x"$ac_exists" = xtrue; then
5039 +  :
5040 + else
5041 +  ac_arg="$ac_arg $ac_j"
5042 +                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5043 + fi
5044 +
5045 +          done
5046 +          ;;
5047 +        -[lLR]*)
5048 +            ac_exists=false
5049 +  for ac_i in $ac_cv_fc_libs; do
5050 +    if test x"$ac_arg" = x"$ac_i"; then
5051 +      ac_exists=true
5052 +      break
5053 +    fi
5054 +  done
5055 +
5056 +  if test x"$ac_exists" = xtrue; then
5057 +  :
5058 + else
5059 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5060 + fi
5061 +
5062 +          ;;
5063 +          # Ignore everything else.
5064 +  esac
5065 + done
5066 + # restore positional arguments
5067 + set X $ac_save_positional; shift
5068 +
5069 + # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5070 + # then we insist that the "run path" must be an absolute path (i.e. it
5071 + # must begin with a "/").
5072 + case `(uname -sr) 2>/dev/null` in
5073 +   "SunOS 5"*)
5074 +      ac_ld_run_path=`echo $ac_fc_v_output |
5075 +                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5076 +      test "x$ac_ld_run_path" != x &&
5077 +        if test "$ac_compiler_gnu" = yes; then
5078 +  for ac_link_opt in $ac_ld_run_path; do
5079 +    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5080 +  done
5081 + else
5082 +  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5083 + fi
5084 +      ;;
5085 + esac
5086 + fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5087 +
5088 + fi
5089 + echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5090 + echo "${ECHO_T}$ac_cv_fc_libs" >&6
5091 + FCLIBS="$ac_cv_fc_libs"
5092 +
5093 +
5094 + ac_ext=${FC_SRCEXT-f}
5095 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5096 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5097 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5098 +
5099 +
5100 +
5101   echo "$as_me:$LINENO: checking for module suffix" >&5
5102   echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5103   rm -f conftest*
5104   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5105   rm -f work*
5106 < cat >conftest.f90 <<EOF
5106 > cat >conftest.$ac_ext <<EOF
5107          module conftest
5108          integer n
5109          parameter (n=1)
# Line 4085 | Line 5112 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5112   # SGI and absoft compilers generates module name in upper case!
5113   testname="conftest"
5114   modcase="lower"
5115 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5116 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
5115 > if (eval $ac_compile) 2>/dev/null ; then
5116 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5117      MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5118      if test -z "$MOD" ; then
5119          MOD=`ls CONFTEST* 2>/dev/null \
5120 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
5120 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5121          MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5122          if test -n "$MOD" ; then
5123              testname="CONFTEST"
# Line 4130 | Line 5157 | cat >conftest.f90 <<EOF
5157   rm -f conftest*
5158   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5159   rm -f work*
5160 < cat >conftest.f90 <<EOF
5160 > cat >conftest.$ac_ext <<EOF
5161          module conftest
5162          integer n
5163          parameter (n=1)
# Line 4138 | Line 5165 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5165   EOF
5166   # SGI and absoft compilers generates module name in upper case!
5167   testname="conftest"
5168 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5169 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
5168 > if (eval $ac_compile) 2>/dev/null ; then
5169 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5170     mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5171     if test -n "$mod" ; then
5172        testname="CONFTEST"
# Line 4148 | Line 5175 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5175     if test ! -d conf ; then mkdir conf ; madedir=1; fi
5176     cp $testname.$MOD conf
5177     rm -f conftest* CONFTEST*
5178 <   cat >conftest1.f90 <<EOF
5178 >   cat >conftest1.$ac_ext <<EOF
5179          program main
5180          use conftest
5181          print *, n
# Line 4156 | Line 5183 | EOF
5183   EOF
5184     F90_WORK_FILES_ARG=""
5185     F90MODINCSPEC=""
5186 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
5186 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5187         MODDIRFLAG="-I"
5188         F90MODINCSPEC="-I<dir>"
5189         echo "$as_me:$LINENO: result: -I" >&5
5190   echo "${ECHO_T}-I" >&6
5191 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
5191 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5192         MODDIRFLAG="-M"
5193         F90MODINCSPEC="-M<dir>"
5194         echo "$as_me:$LINENO: result: -M" >&5
5195   echo "${ECHO_T}-M" >&6
5196 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
5196 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5197         MODDIRFLAG="-p"
5198         F90MODINCSPEC="-p<dir>"
5199         echo "$as_me:$LINENO: result: -p" >&5
# Line 4175 | Line 5202 | echo "${ECHO_T}-p" >&6
5202          cp work.pc conf/mpimod.pc
5203          echo "mpimod.pc" > conf/mpimod.pcl
5204          echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5205 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
5205 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5206              MODDIRFLAG='-cl,mpimod.pcl'
5207              echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5208   echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
# Line 4200 | Line 5227 | ac_ext=c
5227   fi
5228  
5229  
5230 < ac_ext=c
5231 < ac_cpp='$CPP $CPPFLAGS'
5232 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4206 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4207 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4208 <
4209 <
4210 < ac_ext=c
4211 < ac_cpp='$CPP $CPPFLAGS'
4212 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4213 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4214 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4215 <
4216 < ac_ext=c
4217 < ac_cpp='$CPP $CPPFLAGS'
4218 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4219 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4220 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4221 < echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4222 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4223 < # On Suns, sometimes $CPP names a directory.
4224 < if test -n "$CPP" && test -d "$CPP"; then
4225 <  CPP=
4226 < fi
4227 < if test -z "$CPP"; then
4228 <  if test "${ac_cv_prog_CPP+set}" = set; then
5230 > echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5231 > echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
5232 > if test "${ac_cv_f90_module_names+set}" = set; then
5233    echo $ECHO_N "(cached) $ECHO_C" >&6
5234   else
5235 <      # Double quotes because CPP needs to be expanded
5236 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5237 <    do
5238 <      ac_preproc_ok=false
5239 < for ac_c_preproc_warn_flag in '' yes
5240 < do
5241 <  # Use a header file that comes with gcc, so configuring glibc
5242 <  # with a fresh cross-compiler works.
5243 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5244 <  # <limits.h> exists even on freestanding compilers.
5245 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4242 <  # not just through cpp. "Syntax error" is here to catch this case.
4243 <  cat >conftest.$ac_ext <<_ACEOF
4244 < /* confdefs.h.  */
5235 >  ac_ext=${FC_SRCEXT-f}
5236 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5237 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5238 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5239 >
5240 > # carry out the test in a new directory, so that we don't miss anything
5241 > mkdir conftest
5242 > cd conftest
5243 > cat >conftest.$ac_ext <<_ACEOF
5244 > MODULE Bar
5245 > END MODULE Bar
5246   _ACEOF
5247 < cat confdefs.h >>conftest.$ac_ext
5248 < cat >>conftest.$ac_ext <<_ACEOF
5249 < /* end confdefs.h.  */
4249 < #ifdef __STDC__
4250 < # include <limits.h>
4251 < #else
4252 < # include <assert.h>
4253 < #endif
4254 <                     Syntax error
4255 < _ACEOF
4256 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4257 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5247 > rm -f conftest.$ac_objext
5248 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5249 >  (eval $ac_compile) 2>conftest.er1
5250    ac_status=$?
5251    grep -v '^ *+' conftest.er1 >conftest.err
5252    rm -f conftest.er1
5253    cat conftest.err >&5
5254    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5255 <  (exit $ac_status); } >/dev/null; then
5256 <  if test -s conftest.err; then
5257 <    ac_cpp_err=$ac_c_preproc_warn_flag
5258 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5259 <  else
5260 <    ac_cpp_err=
5261 <  fi
5262 < else
5263 <  ac_cpp_err=yes
5264 < fi
5265 < if test -z "$ac_cpp_err"; then
5266 <  :
5267 < else
5268 <  echo "$as_me: failed program was:" >&5
5269 < sed 's/^/| /' conftest.$ac_ext >&5
5270 <
5271 <  # Broken: fails on valid input.
5272 < continue
5273 < fi
5274 < rm -f conftest.err conftest.$ac_ext
5275 <
5276 <  # OK, works on sane cases.  Now check whether non-existent headers
5277 <  # can be detected and how.
5278 <  cat >conftest.$ac_ext <<_ACEOF
5279 < /* confdefs.h.  */
5280 < _ACEOF
5281 < cat confdefs.h >>conftest.$ac_ext
5282 < cat >>conftest.$ac_ext <<_ACEOF
5283 < /* end confdefs.h.  */
5284 < #include <ac_nonexistent.h>
5285 < _ACEOF
5286 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5287 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5288 <  ac_status=$?
5289 <  grep -v '^ *+' conftest.er1 >conftest.err
5290 <  rm -f conftest.er1
5291 <  cat conftest.err >&5
5292 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5293 <  (exit $ac_status); } >/dev/null; then
5294 <  if test -s conftest.err; then
5295 <    ac_cpp_err=$ac_c_preproc_warn_flag
5296 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5297 <  else
5298 <    ac_cpp_err=
5299 <  fi
5300 < else
5301 <  ac_cpp_err=yes
5302 < fi
5303 < if test -z "$ac_cpp_err"; then
5304 <  # Broken: success on invalid input.
5305 < continue
5306 < else
5307 <  echo "$as_me: failed program was:" >&5
5308 < sed 's/^/| /' conftest.$ac_ext >&5
5309 <
5310 <  # Passes both tests.
5311 < ac_preproc_ok=:
5312 < break
5313 < fi
5314 < rm -f conftest.err conftest.$ac_ext
5315 <
5316 < done
5317 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5318 < rm -f conftest.err conftest.$ac_ext
5319 < if $ac_preproc_ok; then
5320 <  break
5321 < fi
5322 <
5323 <    done
5324 <    ac_cv_prog_CPP=$CPP
5325 <
5326 < fi
5327 <  CPP=$ac_cv_prog_CPP
5328 < else
5329 <  ac_cv_prog_CPP=$CPP
5330 < fi
5331 < echo "$as_me:$LINENO: result: $CPP" >&5
5332 < echo "${ECHO_T}$CPP" >&6
5333 < ac_preproc_ok=false
5334 < for ac_c_preproc_warn_flag in '' yes
5335 < do
5336 <  # Use a header file that comes with gcc, so configuring glibc
5337 <  # with a fresh cross-compiler works.
5338 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5339 <  # <limits.h> exists even on freestanding compilers.
5340 <  # On the NeXT, cc -E runs the code through the compiler's parser,
5341 <  # not just through cpp. "Syntax error" is here to catch this case.
5342 <  cat >conftest.$ac_ext <<_ACEOF
5343 < /* confdefs.h.  */
5344 < _ACEOF
5345 < cat confdefs.h >>conftest.$ac_ext
5346 < cat >>conftest.$ac_ext <<_ACEOF
5347 < /* end confdefs.h.  */
5348 < #ifdef __STDC__
5349 < # include <limits.h>
5350 < #else
5351 < # include <assert.h>
5352 < #endif
5353 <                     Syntax error
5354 < _ACEOF
5355 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5356 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5357 <  ac_status=$?
5358 <  grep -v '^ *+' conftest.er1 >conftest.err
5359 <  rm -f conftest.er1
5360 <  cat conftest.err >&5
5361 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5362 <  (exit $ac_status); } >/dev/null; then
5363 <  if test -s conftest.err; then
5364 <    ac_cpp_err=$ac_c_preproc_warn_flag
5365 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5366 <  else
5367 <    ac_cpp_err=
5368 <  fi
5369 < else
5370 <  ac_cpp_err=yes
5371 < fi
5372 < if test -z "$ac_cpp_err"; then
5373 <  :
5374 < else
5375 <  echo "$as_me: failed program was:" >&5
5376 < sed 's/^/| /' conftest.$ac_ext >&5
5377 <
5378 <  # Broken: fails on valid input.
5379 < continue
5380 < fi
5381 < rm -f conftest.err conftest.$ac_ext
5382 <
5383 <  # OK, works on sane cases.  Now check whether non-existent headers
5384 <  # can be detected and how.
5385 <  cat >conftest.$ac_ext <<_ACEOF
5386 < /* confdefs.h.  */
5387 < _ACEOF
5388 < cat confdefs.h >>conftest.$ac_ext
5389 < cat >>conftest.$ac_ext <<_ACEOF
5390 < /* end confdefs.h.  */
5391 < #include <ac_nonexistent.h>
5392 < _ACEOF
5393 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5394 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5395 <  ac_status=$?
5396 <  grep -v '^ *+' conftest.er1 >conftest.err
5397 <  rm -f conftest.er1
5398 <  cat conftest.err >&5
5399 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5400 <  (exit $ac_status); } >/dev/null; then
5401 <  if test -s conftest.err; then
5402 <    ac_cpp_err=$ac_c_preproc_warn_flag
5403 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5404 <  else
5405 <    ac_cpp_err=
5406 <  fi
5407 < else
5408 <  ac_cpp_err=yes
5409 < fi
5410 < if test -z "$ac_cpp_err"; then
5411 <  # Broken: success on invalid input.
5412 < continue
5413 < else
5414 <  echo "$as_me: failed program was:" >&5
5415 < sed 's/^/| /' conftest.$ac_ext >&5
5416 <
5417 <  # Passes both tests.
5418 < ac_preproc_ok=:
5419 < break
5420 < fi
5421 < rm -f conftest.err conftest.$ac_ext
5422 <
5423 < done
5424 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5425 < rm -f conftest.err conftest.$ac_ext
5426 < if $ac_preproc_ok; then
5427 <  :
5428 < else
5429 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
5430 < See \`config.log' for more details." >&5
5431 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
5432 < See \`config.log' for more details." >&2;}
5433 <   { (exit 1); exit 1; }; }
5434 < fi
5435 <
5436 < ac_ext=c
5437 < ac_cpp='$CPP $CPPFLAGS'
5438 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5439 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5440 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
5441 <
5442 <
5443 < echo "$as_me:$LINENO: checking for egrep" >&5
5444 < echo $ECHO_N "checking for egrep... $ECHO_C" >&6
5445 < if test "${ac_cv_prog_egrep+set}" = set; then
5446 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5447 < else
5448 <  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5449 <    then ac_cv_prog_egrep='grep -E'
5450 <    else ac_cv_prog_egrep='egrep'
5451 <    fi
5452 < fi
5453 < echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
5454 < echo "${ECHO_T}$ac_cv_prog_egrep" >&6
5455 < EGREP=$ac_cv_prog_egrep
5456 <
5457 <
5458 < echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5459 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5460 < if test "${ac_cv_header_stdc+set}" = set; then
5461 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5462 < else
5463 <  cat >conftest.$ac_ext <<_ACEOF
5464 < /* confdefs.h.  */
5465 < _ACEOF
5466 < cat confdefs.h >>conftest.$ac_ext
5467 < cat >>conftest.$ac_ext <<_ACEOF
5468 < /* end confdefs.h.  */
5469 < #include <stdlib.h>
5470 < #include <stdarg.h>
5471 < #include <string.h>
5472 < #include <float.h>
5473 <
5474 < int
5475 < main ()
5476 < {
5477 <
5478 <  ;
5479 <  return 0;
5480 < }
5481 < _ACEOF
5482 < rm -f conftest.$ac_objext
5483 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5484 <  (eval $ac_compile) 2>conftest.er1
5485 <  ac_status=$?
5486 <  grep -v '^ *+' conftest.er1 >conftest.err
5487 <  rm -f conftest.er1
5488 <  cat conftest.err >&5
5489 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5490 <  (exit $ac_status); } &&
5491 <         { ac_try='test -z "$ac_c_werror_flag"
5492 <                         || test ! -s conftest.err'
5493 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5494 <  (eval $ac_try) 2>&5
5495 <  ac_status=$?
5496 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5497 <  (exit $ac_status); }; } &&
5498 <         { ac_try='test -s conftest.$ac_objext'
5499 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5500 <  (eval $ac_try) 2>&5
5501 <  ac_status=$?
5502 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5503 <  (exit $ac_status); }; }; then
5504 <  ac_cv_header_stdc=yes
5505 < else
5506 <  echo "$as_me: failed program was:" >&5
5507 < sed 's/^/| /' conftest.$ac_ext >&5
5508 <
5509 < ac_cv_header_stdc=no
5510 < fi
5511 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5512 <
5513 < if test $ac_cv_header_stdc = yes; then
5514 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5515 <  cat >conftest.$ac_ext <<_ACEOF
5516 < /* confdefs.h.  */
5517 < _ACEOF
5518 < cat confdefs.h >>conftest.$ac_ext
5519 < cat >>conftest.$ac_ext <<_ACEOF
5520 < /* end confdefs.h.  */
5521 < #include <string.h>
5522 <
5523 < _ACEOF
5524 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5525 <  $EGREP "memchr" >/dev/null 2>&1; then
5526 <  :
5527 < else
5528 <  ac_cv_header_stdc=no
5529 < fi
5530 < rm -f conftest*
5531 <
5532 < fi
5533 <
5534 < if test $ac_cv_header_stdc = yes; then
5535 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5536 <  cat >conftest.$ac_ext <<_ACEOF
5537 < /* confdefs.h.  */
5538 < _ACEOF
5539 < cat confdefs.h >>conftest.$ac_ext
5540 < cat >>conftest.$ac_ext <<_ACEOF
5541 < /* end confdefs.h.  */
5542 < #include <stdlib.h>
5543 <
5544 < _ACEOF
5545 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5546 <  $EGREP "free" >/dev/null 2>&1; then
5547 <  :
5548 < else
5549 <  ac_cv_header_stdc=no
5550 < fi
5551 < rm -f conftest*
5552 <
5553 < fi
5554 <
5555 < if test $ac_cv_header_stdc = yes; then
5556 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5557 <  if test "$cross_compiling" = yes; then
5558 <  :
5559 < else
5560 <  cat >conftest.$ac_ext <<_ACEOF
5561 < /* confdefs.h.  */
5562 < _ACEOF
5563 < cat confdefs.h >>conftest.$ac_ext
5564 < cat >>conftest.$ac_ext <<_ACEOF
5565 < /* end confdefs.h.  */
5566 < #include <ctype.h>
5567 < #if ((' ' & 0x0FF) == 0x020)
5568 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5569 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5570 < #else
5571 < # define ISLOWER(c) \
5572 <                   (('a' <= (c) && (c) <= 'i') \
5573 <                     || ('j' <= (c) && (c) <= 'r') \
5574 <                     || ('s' <= (c) && (c) <= 'z'))
5575 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5576 < #endif
5577 <
5578 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5579 < int
5580 < main ()
5581 < {
5582 <  int i;
5583 <  for (i = 0; i < 256; i++)
5584 <    if (XOR (islower (i), ISLOWER (i))
5585 <        || toupper (i) != TOUPPER (i))
5586 <      exit(2);
5587 <  exit (0);
5588 < }
5589 < _ACEOF
5590 < rm -f conftest$ac_exeext
5591 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5592 <  (eval $ac_link) 2>&5
5593 <  ac_status=$?
5594 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5595 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5596 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5597 <  (eval $ac_try) 2>&5
5598 <  ac_status=$?
5599 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5600 <  (exit $ac_status); }; }; then
5601 <  :
5602 < else
5603 <  echo "$as_me: program exited with status $ac_status" >&5
5604 < echo "$as_me: failed program was:" >&5
5605 < sed 's/^/| /' conftest.$ac_ext >&5
5606 <
5607 < ( exit $ac_status )
5608 < ac_cv_header_stdc=no
5609 < fi
5610 < rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5611 < fi
5612 < fi
5613 < fi
5614 < echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5615 < echo "${ECHO_T}$ac_cv_header_stdc" >&6
5616 < if test $ac_cv_header_stdc = yes; then
5617 <
5618 < cat >>confdefs.h <<\_ACEOF
5619 < #define STDC_HEADERS 1
5620 < _ACEOF
5621 <
5622 < fi
5623 <
5624 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5625 <
5626 <
5627 <
5628 <
5629 <
5630 <
5631 <
5632 <
5633 <
5634 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5635 <                  inttypes.h stdint.h unistd.h
5636 < do
5637 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5638 < echo "$as_me:$LINENO: checking for $ac_header" >&5
5639 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5640 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5641 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5642 < else
5643 <  cat >conftest.$ac_ext <<_ACEOF
5644 < /* confdefs.h.  */
5645 < _ACEOF
5646 < cat confdefs.h >>conftest.$ac_ext
5647 < cat >>conftest.$ac_ext <<_ACEOF
5648 < /* end confdefs.h.  */
5649 < $ac_includes_default
5650 <
5651 < #include <$ac_header>
5652 < _ACEOF
5653 < rm -f conftest.$ac_objext
5654 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5655 <  (eval $ac_compile) 2>conftest.er1
5656 <  ac_status=$?
5657 <  grep -v '^ *+' conftest.er1 >conftest.err
5658 <  rm -f conftest.er1
5659 <  cat conftest.err >&5
5660 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5661 <  (exit $ac_status); } &&
5662 <         { ac_try='test -z "$ac_c_werror_flag"
5663 <                         || test ! -s conftest.err'
5664 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5665 <  (eval $ac_try) 2>&5
5666 <  ac_status=$?
5667 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5668 <  (exit $ac_status); }; } &&
5669 <         { ac_try='test -s conftest.$ac_objext'
5670 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5671 <  (eval $ac_try) 2>&5
5672 <  ac_status=$?
5673 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5674 <  (exit $ac_status); }; }; then
5675 <  eval "$as_ac_Header=yes"
5676 < else
5677 <  echo "$as_me: failed program was:" >&5
5678 < sed 's/^/| /' conftest.$ac_ext >&5
5679 <
5680 < eval "$as_ac_Header=no"
5681 < fi
5682 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5683 < fi
5684 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5685 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5686 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
5687 <  cat >>confdefs.h <<_ACEOF
5688 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5689 < _ACEOF
5690 <
5691 < fi
5692 <
5693 < done
5694 <
5695 <
5696 <  # clean out junk possibly left behind by a previous configuration
5697 <  rm -f utils/getopt.h
5698 <  # Check for getopt_long support
5699 <
5700 < for ac_header in getopt.h
5701 < do
5702 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5703 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5704 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5705 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5706 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5707 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5708 < fi
5709 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5710 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5711 < else
5712 <  # Is the header compilable?
5713 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
5714 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
5715 < cat >conftest.$ac_ext <<_ACEOF
5716 < /* confdefs.h.  */
5717 < _ACEOF
5718 < cat confdefs.h >>conftest.$ac_ext
5719 < cat >>conftest.$ac_ext <<_ACEOF
5720 < /* end confdefs.h.  */
5721 < $ac_includes_default
5722 < #include <$ac_header>
5723 < _ACEOF
5724 < rm -f conftest.$ac_objext
5725 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5726 <  (eval $ac_compile) 2>conftest.er1
5727 <  ac_status=$?
5728 <  grep -v '^ *+' conftest.er1 >conftest.err
5729 <  rm -f conftest.er1
5730 <  cat conftest.err >&5
5731 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5732 <  (exit $ac_status); } &&
5733 <         { ac_try='test -z "$ac_c_werror_flag"
5734 <                         || test ! -s conftest.err'
5735 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5736 <  (eval $ac_try) 2>&5
5737 <  ac_status=$?
5738 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5739 <  (exit $ac_status); }; } &&
5740 <         { ac_try='test -s conftest.$ac_objext'
5741 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5742 <  (eval $ac_try) 2>&5
5743 <  ac_status=$?
5744 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5745 <  (exit $ac_status); }; }; then
5746 <  ac_header_compiler=yes
5747 < else
5748 <  echo "$as_me: failed program was:" >&5
5749 < sed 's/^/| /' conftest.$ac_ext >&5
5750 <
5751 < ac_header_compiler=no
5752 < fi
5753 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5754 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5755 < echo "${ECHO_T}$ac_header_compiler" >&6
5756 <
5757 < # Is the header present?
5758 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
5759 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
5760 < cat >conftest.$ac_ext <<_ACEOF
5761 < /* confdefs.h.  */
5762 < _ACEOF
5763 < cat confdefs.h >>conftest.$ac_ext
5764 < cat >>conftest.$ac_ext <<_ACEOF
5765 < /* end confdefs.h.  */
5766 < #include <$ac_header>
5767 < _ACEOF
5768 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5769 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5770 <  ac_status=$?
5771 <  grep -v '^ *+' conftest.er1 >conftest.err
5772 <  rm -f conftest.er1
5773 <  cat conftest.err >&5
5774 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5775 <  (exit $ac_status); } >/dev/null; then
5776 <  if test -s conftest.err; then
5777 <    ac_cpp_err=$ac_c_preproc_warn_flag
5778 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5779 <  else
5780 <    ac_cpp_err=
5781 <  fi
5782 < else
5783 <  ac_cpp_err=yes
5784 < fi
5785 < if test -z "$ac_cpp_err"; then
5786 <  ac_header_preproc=yes
5787 < else
5788 <  echo "$as_me: failed program was:" >&5
5789 < sed 's/^/| /' conftest.$ac_ext >&5
5790 <
5791 <  ac_header_preproc=no
5792 < fi
5793 < rm -f conftest.err conftest.$ac_ext
5794 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5795 < echo "${ECHO_T}$ac_header_preproc" >&6
5796 <
5797 < # So?  What about this header?
5798 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5799 <  yes:no: )
5800 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5801 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5802 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5803 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5804 <    ac_header_preproc=yes
5805 <    ;;
5806 <  no:yes:* )
5807 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5808 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5809 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5810 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5811 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5812 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5813 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5814 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5815 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5816 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5817 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5818 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5819 <    (
5820 <      cat <<\_ASBOX
5821 < ## ------------------------------ ##
5822 < ## Report this to gezelter@nd.edu ##
5823 < ## ------------------------------ ##
5824 < _ASBOX
5825 <    ) |
5826 <      sed "s/^/$as_me: WARNING:     /" >&2
5827 <    ;;
5828 < esac
5829 < echo "$as_me:$LINENO: checking for $ac_header" >&5
5830 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5831 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5832 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5833 < else
5834 <  eval "$as_ac_Header=\$ac_header_preproc"
5835 < fi
5836 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5837 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5838 <
5839 < fi
5840 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
5841 <  cat >>confdefs.h <<_ACEOF
5842 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5843 < _ACEOF
5844 <
5845 < fi
5846 <
5847 < done
5848 <
5849 <
5850 < for ac_func in getopt_long
5851 < do
5852 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
5853 < echo "$as_me:$LINENO: checking for $ac_func" >&5
5854 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
5855 < if eval "test \"\${$as_ac_var+set}\" = set"; then
5856 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5857 < else
5858 <  cat >conftest.$ac_ext <<_ACEOF
5859 < /* confdefs.h.  */
5860 < _ACEOF
5861 < cat confdefs.h >>conftest.$ac_ext
5862 < cat >>conftest.$ac_ext <<_ACEOF
5863 < /* end confdefs.h.  */
5864 < /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
5865 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
5866 < #define $ac_func innocuous_$ac_func
5867 <
5868 < /* System header to define __stub macros and hopefully few prototypes,
5869 <    which can conflict with char $ac_func (); below.
5870 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5871 <    <limits.h> exists even on freestanding compilers.  */
5872 <
5873 < #ifdef __STDC__
5874 < # include <limits.h>
5875 < #else
5876 < # include <assert.h>
5877 < #endif
5878 <
5879 < #undef $ac_func
5255 >  (exit $ac_status); } &&
5256 >         { ac_try='test -z "$ac_fc_werror_flag"
5257 >                         || test ! -s conftest.err'
5258 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5259 >  (eval $ac_try) 2>&5
5260 >  ac_status=$?
5261 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5262 >  (exit $ac_status); }; } &&
5263 >         { ac_try='test -s conftest.$ac_objext'
5264 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5265 >  (eval $ac_try) 2>&5
5266 >  ac_status=$?
5267 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5268 >  (exit $ac_status); }; }; then
5269 >  ac_cv_f90_module_names=
5270 > ac_file_list=*
5271 > for ac_file in $ac_file_list; do
5272 >   case $ac_file in
5273 >      # don't care for original source and object files
5274 >      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
5275 >          :
5276 >          ;;
5277 >      # look for new files derived from the file name
5278 >      *conftest*)
5279 >          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
5280 >            ac_exists=false
5281 >  for ac_i in $ac_cv_f90_module_names; do
5282 >    if test x"$ac_pat" = x"$ac_i"; then
5283 >      ac_exists=true
5284 >      break
5285 >    fi
5286 >  done
5287 >
5288 >  if test x"$ac_exists" = xtrue; then
5289 >  :
5290 > else
5291 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5292 > fi
5293 >
5294 >          ;;
5295 >      # look for new files derived from the module name,
5296 >      # with different case translation schemes
5297 >      *Bar*)
5298 >          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
5299 >            ac_exists=false
5300 >  for ac_i in $ac_cv_f90_module_names; do
5301 >    if test x"$ac_pat" = x"$ac_i"; then
5302 >      ac_exists=true
5303 >      break
5304 >    fi
5305 >  done
5306 >
5307 >  if test x"$ac_exists" = xtrue; then
5308 >  :
5309 > else
5310 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5311 > fi
5312 >
5313 >          ;;
5314 >      *bar*)
5315 >          ac_pat=`echo $ac_file | sed s/bar/%module%/`
5316 >            ac_exists=false
5317 >  for ac_i in $ac_cv_f90_module_names; do
5318 >    if test x"$ac_pat" = x"$ac_i"; then
5319 >      ac_exists=true
5320 >      break
5321 >    fi
5322 >  done
5323 >
5324 >  if test x"$ac_exists" = xtrue; then
5325 >  :
5326 > else
5327 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5328 > fi
5329 >
5330 >          ;;
5331 >      *BAR*)
5332 >          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
5333 >            ac_exists=false
5334 >  for ac_i in $ac_cv_f90_module_names; do
5335 >    if test x"$ac_pat" = x"$ac_i"; then
5336 >      ac_exists=true
5337 >      break
5338 >    fi
5339 >  done
5340 >
5341 >  if test x"$ac_exists" = xtrue; then
5342 >  :
5343 > else
5344 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5345 > fi
5346 >
5347 >          ;;
5348 >       # Other files - we have no idea how they are generated
5349 >       *)
5350 >          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
5351 > echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
5352 >          ;;
5353 >   esac
5354 > done
5355 > if test "x$ac_cv_f90_module_names" = "x"; then
5356 >  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5357 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5358 > fi
5359 >
5360 > else
5361 >  echo "$as_me: failed program was:" >&5
5362 > sed 's/^/| /' conftest.$ac_ext >&5
5363 >
5364 > ac_cv_f90_module_names=
5365 > { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5366 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5367 > fi
5368 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5369 > cd ..
5370 > # cleanup
5371 > rm -rf conftest
5372 > ac_ext=${FC_SRCEXT-f}
5373 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5374 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5375 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5376 >
5377 > fi
5378 > echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
5379 > echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
5380 >
5381 > # We now generate a shell script that will help us to figure out the correct
5382 > # module file names, using the value of ac_cv_f90_module_names
5383 >
5384 > echo "Generating shell script modnam"
5385 >
5386 > cat > scripts/modnam << EOF
5387 > #! /bin/sh
5388 > # This script is auto-generated by configure
5389 > #
5390 > usage="\\
5391 > Usage: \$0 [FILES]
5392 >
5393 > [FILES] are Fortran 90 source files.
5394 > The output is a list of module file names that the Fortran 90 compiler
5395 > generates when compiling [FILES]."
5396 >
5397 > list=
5398 > empty=
5399 >
5400 > if test \$# -eq 0; then
5401 >   echo "\$usage"; exit 0
5402 > fi
5403 >
5404 > while test \$# != 0; do
5405 >
5406 >  file=\$1
5407 >  shift
5408 >
5409 > # strip suffix
5410 >  base=\`echo \$file | sed 's/[.][^.]*$//'\`
5411 >
5412 >  test ! -f \$file && continue
5413 >
5414 > # Look for module definitions and transform them to upper / lower case
5415 >  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/'\`
5416 >  upper=\`echo \$mods | tr a-z A-Z\`
5417 >  lower=\`echo \$mods | tr A-Z a-z\`
5418 >
5419 > # Here, the patterns for generating module file names were inserted by configure
5420 >  for trans in $ac_cv_f90_module_names; do
5421 >
5422 >    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
5423 >    var=empty
5424 >    case \$pat in
5425 >       %MODULE%)
5426 >          var=upper ;;
5427 >       %Module%)
5428 >          var=mods ;;
5429 >       %module%)
5430 >          var=lower ;;
5431 >       %FILE%)
5432 >          test -n "\$mods" && var=base ;;
5433 >    esac
5434 >    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
5435 >    list="\$list \$new"
5436 >  done
5437 > done
5438 >
5439 > echo \$list
5440 > # end of configure-generated script
5441 > EOF
5442 > chmod 755 scripts/modnam
5443 >
5444 > pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
5445 > F90_MODULE_NAMES=empty
5446 > case $pat in
5447 >       %MODULE%)
5448 >          F90_MODULE_NAMES=UPPER ;;
5449 >       %Module%)
5450 >          F90_MODULE_NAMES=Mixed ;;
5451 >       %module%)
5452 >          F90_MODULE_NAMES=lower ;;
5453 >       *)
5454 >          F90_MODULE_NAMES=unknown ;;
5455 > esac
5456 >
5457 > ac_ext=c
5458 > ac_cpp='$CPP $CPPFLAGS'
5459 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5460 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5461 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5462 >
5463 >
5464 > ac_ext=c
5465 > ac_cpp='$CPP $CPPFLAGS'
5466 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5467 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5468 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5469 >
5470 >
5471 >
5472 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5473 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5474 > if test "${ac_cv_lib_m_asin+set}" = set; then
5475 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5476 > else
5477 >  ac_check_lib_save_LIBS=$LIBS
5478 > LIBS="-lm  $LIBS"
5479 > cat >conftest.$ac_ext <<_ACEOF
5480 > /* confdefs.h.  */
5481 > _ACEOF
5482 > cat confdefs.h >>conftest.$ac_ext
5483 > cat >>conftest.$ac_ext <<_ACEOF
5484 > /* end confdefs.h.  */
5485 >
5486 > /* Override any gcc2 internal prototype to avoid an error.  */
5487 > #ifdef __cplusplus
5488 > extern "C"
5489 > #endif
5490 > /* We use char because int might match the return type of a gcc2
5491 >   builtin and then its argument prototype would still apply.  */
5492 > char asin ();
5493 > #ifdef FC_DUMMY_MAIN
5494 > #ifndef FC_DUMMY_MAIN_EQ_F77
5495 > #  ifdef __cplusplus
5496 >     extern "C"
5497 > #  endif
5498 >   int FC_DUMMY_MAIN() { return 1; }
5499 > #endif
5500 > #endif
5501 > int
5502 > main ()
5503 > {
5504 > asin ();
5505 >  ;
5506 >  return 0;
5507 > }
5508 > _ACEOF
5509 > rm -f conftest.$ac_objext conftest$ac_exeext
5510 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5511 >  (eval $ac_link) 2>conftest.er1
5512 >  ac_status=$?
5513 >  grep -v '^ *+' conftest.er1 >conftest.err
5514 >  rm -f conftest.er1
5515 >  cat conftest.err >&5
5516 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5517 >  (exit $ac_status); } &&
5518 >         { ac_try='test -z "$ac_c_werror_flag"
5519 >                         || test ! -s conftest.err'
5520 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5521 >  (eval $ac_try) 2>&5
5522 >  ac_status=$?
5523 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5524 >  (exit $ac_status); }; } &&
5525 >         { ac_try='test -s conftest$ac_exeext'
5526 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5527 >  (eval $ac_try) 2>&5
5528 >  ac_status=$?
5529 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5530 >  (exit $ac_status); }; }; then
5531 >  ac_cv_lib_m_asin=yes
5532 > else
5533 >  echo "$as_me: failed program was:" >&5
5534 > sed 's/^/| /' conftest.$ac_ext >&5
5535 >
5536 > ac_cv_lib_m_asin=no
5537 > fi
5538 > rm -f conftest.err conftest.$ac_objext \
5539 >      conftest$ac_exeext conftest.$ac_ext
5540 > LIBS=$ac_check_lib_save_LIBS
5541 > fi
5542 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5543 > echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5544 > if test $ac_cv_lib_m_asin = yes; then
5545 >  cat >>confdefs.h <<_ACEOF
5546 > #define HAVE_LIBM 1
5547 > _ACEOF
5548 >
5549 >  LIBS="-lm $LIBS"
5550 >
5551 > else
5552 >  exit
5553 > fi
5554 >
5555 >
5556 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5557 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5558 > if test "${ac_cv_header_stdc+set}" = set; then
5559 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5560 > else
5561 >  cat >conftest.$ac_ext <<_ACEOF
5562 > /* confdefs.h.  */
5563 > _ACEOF
5564 > cat confdefs.h >>conftest.$ac_ext
5565 > cat >>conftest.$ac_ext <<_ACEOF
5566 > /* end confdefs.h.  */
5567 > #include <stdlib.h>
5568 > #include <stdarg.h>
5569 > #include <string.h>
5570 > #include <float.h>
5571 >
5572 > #ifdef FC_DUMMY_MAIN
5573 > #ifndef FC_DUMMY_MAIN_EQ_F77
5574 > #  ifdef __cplusplus
5575 >     extern "C"
5576 > #  endif
5577 >   int FC_DUMMY_MAIN() { return 1; }
5578 > #endif
5579 > #endif
5580 > int
5581 > main ()
5582 > {
5583 >
5584 >  ;
5585 >  return 0;
5586 > }
5587 > _ACEOF
5588 > rm -f conftest.$ac_objext
5589 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5590 >  (eval $ac_compile) 2>conftest.er1
5591 >  ac_status=$?
5592 >  grep -v '^ *+' conftest.er1 >conftest.err
5593 >  rm -f conftest.er1
5594 >  cat conftest.err >&5
5595 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5596 >  (exit $ac_status); } &&
5597 >         { ac_try='test -z "$ac_c_werror_flag"
5598 >                         || test ! -s conftest.err'
5599 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5600 >  (eval $ac_try) 2>&5
5601 >  ac_status=$?
5602 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5603 >  (exit $ac_status); }; } &&
5604 >         { ac_try='test -s conftest.$ac_objext'
5605 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5606 >  (eval $ac_try) 2>&5
5607 >  ac_status=$?
5608 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5609 >  (exit $ac_status); }; }; then
5610 >  ac_cv_header_stdc=yes
5611 > else
5612 >  echo "$as_me: failed program was:" >&5
5613 > sed 's/^/| /' conftest.$ac_ext >&5
5614 >
5615 > ac_cv_header_stdc=no
5616 > fi
5617 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5618 >
5619 > if test $ac_cv_header_stdc = yes; then
5620 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5621 >  cat >conftest.$ac_ext <<_ACEOF
5622 > /* confdefs.h.  */
5623 > _ACEOF
5624 > cat confdefs.h >>conftest.$ac_ext
5625 > cat >>conftest.$ac_ext <<_ACEOF
5626 > /* end confdefs.h.  */
5627 > #include <string.h>
5628 >
5629 > _ACEOF
5630 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5631 >  $EGREP "memchr" >/dev/null 2>&1; then
5632 >  :
5633 > else
5634 >  ac_cv_header_stdc=no
5635 > fi
5636 > rm -f conftest*
5637 >
5638 > fi
5639 >
5640 > if test $ac_cv_header_stdc = yes; then
5641 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5642 >  cat >conftest.$ac_ext <<_ACEOF
5643 > /* confdefs.h.  */
5644 > _ACEOF
5645 > cat confdefs.h >>conftest.$ac_ext
5646 > cat >>conftest.$ac_ext <<_ACEOF
5647 > /* end confdefs.h.  */
5648 > #include <stdlib.h>
5649 >
5650 > _ACEOF
5651 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5652 >  $EGREP "free" >/dev/null 2>&1; then
5653 >  :
5654 > else
5655 >  ac_cv_header_stdc=no
5656 > fi
5657 > rm -f conftest*
5658 >
5659 > fi
5660 >
5661 > if test $ac_cv_header_stdc = yes; then
5662 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5663 >  if test "$cross_compiling" = yes; then
5664 >  :
5665 > else
5666 >  cat >conftest.$ac_ext <<_ACEOF
5667 > /* confdefs.h.  */
5668 > _ACEOF
5669 > cat confdefs.h >>conftest.$ac_ext
5670 > cat >>conftest.$ac_ext <<_ACEOF
5671 > /* end confdefs.h.  */
5672 > #include <ctype.h>
5673 > #if ((' ' & 0x0FF) == 0x020)
5674 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5675 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5676 > #else
5677 > # define ISLOWER(c) \
5678 >                   (('a' <= (c) && (c) <= 'i') \
5679 >                     || ('j' <= (c) && (c) <= 'r') \
5680 >                     || ('s' <= (c) && (c) <= 'z'))
5681 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5682 > #endif
5683 >
5684 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5685 > int
5686 > main ()
5687 > {
5688 >  int i;
5689 >  for (i = 0; i < 256; i++)
5690 >    if (XOR (islower (i), ISLOWER (i))
5691 >        || toupper (i) != TOUPPER (i))
5692 >      exit(2);
5693 >  exit (0);
5694 > }
5695 > _ACEOF
5696 > rm -f conftest$ac_exeext
5697 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5698 >  (eval $ac_link) 2>&5
5699 >  ac_status=$?
5700 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5701 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5702 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5703 >  (eval $ac_try) 2>&5
5704 >  ac_status=$?
5705 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5706 >  (exit $ac_status); }; }; then
5707 >  :
5708 > else
5709 >  echo "$as_me: program exited with status $ac_status" >&5
5710 > echo "$as_me: failed program was:" >&5
5711 > sed 's/^/| /' conftest.$ac_ext >&5
5712 >
5713 > ( exit $ac_status )
5714 > ac_cv_header_stdc=no
5715 > fi
5716 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5717 > fi
5718 > fi
5719 > fi
5720 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5721 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
5722 > if test $ac_cv_header_stdc = yes; then
5723 >
5724 > cat >>confdefs.h <<\_ACEOF
5725 > #define STDC_HEADERS 1
5726 > _ACEOF
5727 >
5728 > fi
5729 >
5730 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5731 >
5732 >
5733 >
5734 >
5735 >
5736 >
5737 >
5738 >
5739 >
5740 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5741 >                  inttypes.h stdint.h unistd.h
5742 > do
5743 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5744 > echo "$as_me:$LINENO: checking for $ac_header" >&5
5745 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5746 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
5747 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5748 > else
5749 >  cat >conftest.$ac_ext <<_ACEOF
5750 > /* confdefs.h.  */
5751 > _ACEOF
5752 > cat confdefs.h >>conftest.$ac_ext
5753 > cat >>conftest.$ac_ext <<_ACEOF
5754 > /* end confdefs.h.  */
5755 > $ac_includes_default
5756 >
5757 > #include <$ac_header>
5758 > _ACEOF
5759 > rm -f conftest.$ac_objext
5760 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5761 >  (eval $ac_compile) 2>conftest.er1
5762 >  ac_status=$?
5763 >  grep -v '^ *+' conftest.er1 >conftest.err
5764 >  rm -f conftest.er1
5765 >  cat conftest.err >&5
5766 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5767 >  (exit $ac_status); } &&
5768 >         { ac_try='test -z "$ac_c_werror_flag"
5769 >                         || test ! -s conftest.err'
5770 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5771 >  (eval $ac_try) 2>&5
5772 >  ac_status=$?
5773 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5774 >  (exit $ac_status); }; } &&
5775 >         { ac_try='test -s conftest.$ac_objext'
5776 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5777 >  (eval $ac_try) 2>&5
5778 >  ac_status=$?
5779 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5780 >  (exit $ac_status); }; }; then
5781 >  eval "$as_ac_Header=yes"
5782 > else
5783 >  echo "$as_me: failed program was:" >&5
5784 > sed 's/^/| /' conftest.$ac_ext >&5
5785 >
5786 > eval "$as_ac_Header=no"
5787 > fi
5788 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5789 > fi
5790 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5791 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5792 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
5793 >  cat >>confdefs.h <<_ACEOF
5794 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5795 > _ACEOF
5796 >
5797 > fi
5798 >
5799 > done
5800 >
5801 >
5802 > #
5803 > # Handle user hints
5804 > #
5805 >
5806 > # Check whether --with-zlib or --without-zlib was given.
5807 > if test "${with_zlib+set}" = set; then
5808 >  withval="$with_zlib"
5809 >  zlib_dir="$withval"
5810 > else
5811 >                zlib_dir="not_set"
5812 > fi;
5813 > if test "$zlib_dir" != "no"; then
5814 >
5815 > if test "$zlib_dir" != "not_set" ; then
5816 >  if test -d "$zlib_dir"
5817 >  then
5818 >    ZLIB_HOME="$zlib_dir"
5819 >  else
5820 >    { echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5821 > echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5822 >  fi
5823 > fi
5824 >
5825 > ZLIB_HOME=/usr/local
5826 > if test ! -f "${ZLIB_HOME}/include/zlib.h"
5827 > then
5828 >        ZLIB_HOME=/usr
5829 > fi
5830 >
5831 > #
5832 > # Locate zlib, if wanted
5833 > #
5834 > if test -n "${ZLIB_HOME}"
5835 > then
5836 >        ZLIB_OLD_LDFLAGS=$LDFLAGS
5837 >        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5838 >        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5839 >        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5840 >
5841 >
5842 >        ac_ext=c
5843 > ac_cpp='$CPP $CPPFLAGS'
5844 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5845 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5846 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5847 >
5848 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5849 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5850 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5851 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5852 > else
5853 >  ac_check_lib_save_LIBS=$LIBS
5854 > LIBS="-lz  $LIBS"
5855 > cat >conftest.$ac_ext <<_ACEOF
5856 > /* confdefs.h.  */
5857 > _ACEOF
5858 > cat confdefs.h >>conftest.$ac_ext
5859 > cat >>conftest.$ac_ext <<_ACEOF
5860 > /* end confdefs.h.  */
5861 >
5862 > /* Override any gcc2 internal prototype to avoid an error.  */
5863 > #ifdef __cplusplus
5864 > extern "C"
5865 > #endif
5866 > /* We use char because int might match the return type of a gcc2
5867 >   builtin and then its argument prototype would still apply.  */
5868 > char inflateEnd ();
5869 > #ifdef FC_DUMMY_MAIN
5870 > #ifndef FC_DUMMY_MAIN_EQ_F77
5871 > #  ifdef __cplusplus
5872 >     extern "C"
5873 > #  endif
5874 >   int FC_DUMMY_MAIN() { return 1; }
5875 > #endif
5876 > #endif
5877 > int
5878 > main ()
5879 > {
5880 > inflateEnd ();
5881 >  ;
5882 >  return 0;
5883 > }
5884 > _ACEOF
5885 > rm -f conftest.$ac_objext conftest$ac_exeext
5886 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5887 >  (eval $ac_link) 2>conftest.er1
5888 >  ac_status=$?
5889 >  grep -v '^ *+' conftest.er1 >conftest.err
5890 >  rm -f conftest.er1
5891 >  cat conftest.err >&5
5892 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5893 >  (exit $ac_status); } &&
5894 >         { ac_try='test -z "$ac_c_werror_flag"
5895 >                         || test ! -s conftest.err'
5896 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5897 >  (eval $ac_try) 2>&5
5898 >  ac_status=$?
5899 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5900 >  (exit $ac_status); }; } &&
5901 >         { ac_try='test -s conftest$ac_exeext'
5902 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5903 >  (eval $ac_try) 2>&5
5904 >  ac_status=$?
5905 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5906 >  (exit $ac_status); }; }; then
5907 >  ac_cv_lib_z_inflateEnd=yes
5908 > else
5909 >  echo "$as_me: failed program was:" >&5
5910 > sed 's/^/| /' conftest.$ac_ext >&5
5911 >
5912 > ac_cv_lib_z_inflateEnd=no
5913 > fi
5914 > rm -f conftest.err conftest.$ac_objext \
5915 >      conftest$ac_exeext conftest.$ac_ext
5916 > LIBS=$ac_check_lib_save_LIBS
5917 > fi
5918 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5919 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5920 > if test $ac_cv_lib_z_inflateEnd = yes; then
5921 >  zlib_cv_libz=yes
5922 > else
5923 >  zlib_cv_libz=no
5924 > fi
5925 >
5926 >        if test "${ac_cv_header_zlib_h+set}" = set; then
5927 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
5928 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5929 > if test "${ac_cv_header_zlib_h+set}" = set; then
5930 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5931 > fi
5932 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5933 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5934 > else
5935 >  # Is the header compilable?
5936 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
5937 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5938 > cat >conftest.$ac_ext <<_ACEOF
5939 > /* confdefs.h.  */
5940 > _ACEOF
5941 > cat confdefs.h >>conftest.$ac_ext
5942 > cat >>conftest.$ac_ext <<_ACEOF
5943 > /* end confdefs.h.  */
5944 > $ac_includes_default
5945 > #include <zlib.h>
5946 > _ACEOF
5947 > rm -f conftest.$ac_objext
5948 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5949 >  (eval $ac_compile) 2>conftest.er1
5950 >  ac_status=$?
5951 >  grep -v '^ *+' conftest.er1 >conftest.err
5952 >  rm -f conftest.er1
5953 >  cat conftest.err >&5
5954 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5955 >  (exit $ac_status); } &&
5956 >         { ac_try='test -z "$ac_c_werror_flag"
5957 >                         || test ! -s conftest.err'
5958 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5959 >  (eval $ac_try) 2>&5
5960 >  ac_status=$?
5961 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5962 >  (exit $ac_status); }; } &&
5963 >         { ac_try='test -s conftest.$ac_objext'
5964 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5965 >  (eval $ac_try) 2>&5
5966 >  ac_status=$?
5967 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5968 >  (exit $ac_status); }; }; then
5969 >  ac_header_compiler=yes
5970 > else
5971 >  echo "$as_me: failed program was:" >&5
5972 > sed 's/^/| /' conftest.$ac_ext >&5
5973 >
5974 > ac_header_compiler=no
5975 > fi
5976 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5977 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5978 > echo "${ECHO_T}$ac_header_compiler" >&6
5979 >
5980 > # Is the header present?
5981 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
5982 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5983 > cat >conftest.$ac_ext <<_ACEOF
5984 > /* confdefs.h.  */
5985 > _ACEOF
5986 > cat confdefs.h >>conftest.$ac_ext
5987 > cat >>conftest.$ac_ext <<_ACEOF
5988 > /* end confdefs.h.  */
5989 > #include <zlib.h>
5990 > _ACEOF
5991 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5992 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5993 >  ac_status=$?
5994 >  grep -v '^ *+' conftest.er1 >conftest.err
5995 >  rm -f conftest.er1
5996 >  cat conftest.err >&5
5997 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5998 >  (exit $ac_status); } >/dev/null; then
5999 >  if test -s conftest.err; then
6000 >    ac_cpp_err=$ac_c_preproc_warn_flag
6001 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6002 >  else
6003 >    ac_cpp_err=
6004 >  fi
6005 > else
6006 >  ac_cpp_err=yes
6007 > fi
6008 > if test -z "$ac_cpp_err"; then
6009 >  ac_header_preproc=yes
6010 > else
6011 >  echo "$as_me: failed program was:" >&5
6012 > sed 's/^/| /' conftest.$ac_ext >&5
6013 >
6014 >  ac_header_preproc=no
6015 > fi
6016 > rm -f conftest.err conftest.$ac_ext
6017 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6018 > echo "${ECHO_T}$ac_header_preproc" >&6
6019 >
6020 > # So?  What about this header?
6021 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6022 >  yes:no: )
6023 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
6024 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6025 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
6026 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
6027 >    ac_header_preproc=yes
6028 >    ;;
6029 >  no:yes:* )
6030 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
6031 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
6032 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
6033 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
6034 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
6035 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
6036 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
6037 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6038 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
6039 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6040 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6041 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6042 >    (
6043 >      cat <<\_ASBOX
6044 > ## ------------------------------ ##
6045 > ## Report this to gezelter@nd.edu ##
6046 > ## ------------------------------ ##
6047 > _ASBOX
6048 >    ) |
6049 >      sed "s/^/$as_me: WARNING:     /" >&2
6050 >    ;;
6051 > esac
6052 > echo "$as_me:$LINENO: checking for zlib.h" >&5
6053 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6054 > if test "${ac_cv_header_zlib_h+set}" = set; then
6055 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6056 > else
6057 >  ac_cv_header_zlib_h=$ac_header_preproc
6058 > fi
6059 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6060 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6061 >
6062 > fi
6063 > if test $ac_cv_header_zlib_h = yes; then
6064 >  zlib_cv_zlib_h=yes
6065 > else
6066 >  zlib_cv_zlib_h=no
6067 > fi
6068 >
6069 >
6070 >        ac_ext=c
6071 > ac_cpp='$CPP $CPPFLAGS'
6072 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6073 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6074 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6075 >
6076 >
6077 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
6078 >
6079 > cat >>confdefs.h <<\_ACEOF
6080 > #define HAVE_ZLIB_H 1
6081 > _ACEOF
6082 >
6083 >
6084 > cat >>confdefs.h <<\_ACEOF
6085 > #define HAVE_LIBZ 1
6086 > _ACEOF
6087 >
6088 >                ZLIB_INC_DIR="${ZLIB_HOME}/include"
6089 >                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
6090 >                ZLIB="-lz"
6091 >        else
6092 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6093 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6094 >                ZLIB_INC_DIR=
6095 >                ZLIB_LIB_DIR=
6096 >                ZLIB=
6097 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6098 >                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6099 >                echo "$as_me:$LINENO: result: failed" >&5
6100 > echo "${ECHO_T}failed" >&6
6101 >                echo ""
6102 >                echo "*********************************************************"
6103 >                echo "* WARNING: Could not find a working zlib installation   *"
6104 >                echo "* If you need OOPSE to be able to deal with compressed  *"
6105 >                echo "* trajectory dump files be sure to specify a valid zlib *"
6106 >                echo "* installation with --with-zlib=DIR                     *"
6107 >                echo "*                                                       *"
6108 >                echo "* OOPSE will still work without zlib installed.         *"
6109 >                echo "*********************************************************"
6110 >                echo ""
6111 >        fi
6112 >
6113 >
6114 >
6115 > fi
6116 > fi
6117 >
6118 > #
6119 > # Handle user hints
6120 > #
6121 >
6122 > # Check whether --with-fftw or --without-fftw was given.
6123 > if test "${with_fftw+set}" = set; then
6124 >  withval="$with_fftw"
6125 >  fftw_dir="$withval"
6126 > else
6127 >                fftw_dir="not_set"
6128 > fi;
6129 > if test "$fftw_dir" != "no"; then
6130 >
6131 > if test "$fftw_dir" != "not_set" ; then
6132 >  if test -d "$fftw_dir"
6133 >  then
6134 >    FFTW_HOME="$fftw_dir"
6135 >  else
6136 >    { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6137 > echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6138 >  fi
6139 > fi
6140 >
6141 > FFTW_HOME=/usr/local
6142 > if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"
6143 > then
6144 >        FFTW_HOME=/usr
6145 > fi
6146 >
6147 > #
6148 > # Locate fftw, if wanted
6149 > #
6150 > if test -n "${FFTW_HOME}"
6151 > then
6152 >        FFTW_OLD_LDFLAGS=$LDFLAGS
6153 >        FFTW_OLD_CPPFLAGS=$LDFLAGS
6154 >        LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6155 >        CPPFLAGS="$CPPFLAGS -I${FFTW_HOME}/include"
6156 >
6157 >
6158 >        ac_ext=c
6159 > ac_cpp='$CPP $CPPFLAGS'
6160 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6161 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6162 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6163 >
6164 >        echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6165 > echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6166 > if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6167 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6168 > else
6169 >  ac_check_lib_save_LIBS=$LIBS
6170 > LIBS="-lfftw3  $LIBS"
6171 > cat >conftest.$ac_ext <<_ACEOF
6172 > /* confdefs.h.  */
6173 > _ACEOF
6174 > cat confdefs.h >>conftest.$ac_ext
6175 > cat >>conftest.$ac_ext <<_ACEOF
6176 > /* end confdefs.h.  */
6177 >
6178 > /* Override any gcc2 internal prototype to avoid an error.  */
6179 > #ifdef __cplusplus
6180 > extern "C"
6181 > #endif
6182 > /* We use char because int might match the return type of a gcc2
6183 >   builtin and then its argument prototype would still apply.  */
6184 > char fftw_execute ();
6185 > #ifdef FC_DUMMY_MAIN
6186 > #ifndef FC_DUMMY_MAIN_EQ_F77
6187 > #  ifdef __cplusplus
6188 >     extern "C"
6189 > #  endif
6190 >   int FC_DUMMY_MAIN() { return 1; }
6191 > #endif
6192 > #endif
6193 > int
6194 > main ()
6195 > {
6196 > fftw_execute ();
6197 >  ;
6198 >  return 0;
6199 > }
6200 > _ACEOF
6201 > rm -f conftest.$ac_objext conftest$ac_exeext
6202 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6203 >  (eval $ac_link) 2>conftest.er1
6204 >  ac_status=$?
6205 >  grep -v '^ *+' conftest.er1 >conftest.err
6206 >  rm -f conftest.er1
6207 >  cat conftest.err >&5
6208 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6209 >  (exit $ac_status); } &&
6210 >         { ac_try='test -z "$ac_c_werror_flag"
6211 >                         || test ! -s conftest.err'
6212 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6213 >  (eval $ac_try) 2>&5
6214 >  ac_status=$?
6215 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6216 >  (exit $ac_status); }; } &&
6217 >         { ac_try='test -s conftest$ac_exeext'
6218 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6219 >  (eval $ac_try) 2>&5
6220 >  ac_status=$?
6221 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6222 >  (exit $ac_status); }; }; then
6223 >  ac_cv_lib_fftw3_fftw_execute=yes
6224 > else
6225 >  echo "$as_me: failed program was:" >&5
6226 > sed 's/^/| /' conftest.$ac_ext >&5
6227 >
6228 > ac_cv_lib_fftw3_fftw_execute=no
6229 > fi
6230 > rm -f conftest.err conftest.$ac_objext \
6231 >      conftest$ac_exeext conftest.$ac_ext
6232 > LIBS=$ac_check_lib_save_LIBS
6233 > fi
6234 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6235 > echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6236 > if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6237 >  fftw_cv_libfftw3=yes
6238 > else
6239 >  fftw_cv_libfftw3=no
6240 > fi
6241 >
6242 >        if test "${ac_cv_header_fftw3_h+set}" = set; then
6243 >  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6244 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6245 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6246 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6247 > fi
6248 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6249 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6250 > else
6251 >  # Is the header compilable?
6252 > echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6253 > echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6254 > cat >conftest.$ac_ext <<_ACEOF
6255 > /* confdefs.h.  */
6256 > _ACEOF
6257 > cat confdefs.h >>conftest.$ac_ext
6258 > cat >>conftest.$ac_ext <<_ACEOF
6259 > /* end confdefs.h.  */
6260 > $ac_includes_default
6261 > #include <fftw3.h>
6262 > _ACEOF
6263 > rm -f conftest.$ac_objext
6264 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6265 >  (eval $ac_compile) 2>conftest.er1
6266 >  ac_status=$?
6267 >  grep -v '^ *+' conftest.er1 >conftest.err
6268 >  rm -f conftest.er1
6269 >  cat conftest.err >&5
6270 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6271 >  (exit $ac_status); } &&
6272 >         { ac_try='test -z "$ac_c_werror_flag"
6273 >                         || test ! -s conftest.err'
6274 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6275 >  (eval $ac_try) 2>&5
6276 >  ac_status=$?
6277 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6278 >  (exit $ac_status); }; } &&
6279 >         { ac_try='test -s conftest.$ac_objext'
6280 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6281 >  (eval $ac_try) 2>&5
6282 >  ac_status=$?
6283 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6284 >  (exit $ac_status); }; }; then
6285 >  ac_header_compiler=yes
6286 > else
6287 >  echo "$as_me: failed program was:" >&5
6288 > sed 's/^/| /' conftest.$ac_ext >&5
6289 >
6290 > ac_header_compiler=no
6291 > fi
6292 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6293 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6294 > echo "${ECHO_T}$ac_header_compiler" >&6
6295 >
6296 > # Is the header present?
6297 > echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6298 > echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6299 > cat >conftest.$ac_ext <<_ACEOF
6300 > /* confdefs.h.  */
6301 > _ACEOF
6302 > cat confdefs.h >>conftest.$ac_ext
6303 > cat >>conftest.$ac_ext <<_ACEOF
6304 > /* end confdefs.h.  */
6305 > #include <fftw3.h>
6306 > _ACEOF
6307 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6308 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6309 >  ac_status=$?
6310 >  grep -v '^ *+' conftest.er1 >conftest.err
6311 >  rm -f conftest.er1
6312 >  cat conftest.err >&5
6313 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6314 >  (exit $ac_status); } >/dev/null; then
6315 >  if test -s conftest.err; then
6316 >    ac_cpp_err=$ac_c_preproc_warn_flag
6317 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6318 >  else
6319 >    ac_cpp_err=
6320 >  fi
6321 > else
6322 >  ac_cpp_err=yes
6323 > fi
6324 > if test -z "$ac_cpp_err"; then
6325 >  ac_header_preproc=yes
6326 > else
6327 >  echo "$as_me: failed program was:" >&5
6328 > sed 's/^/| /' conftest.$ac_ext >&5
6329 >
6330 >  ac_header_preproc=no
6331 > fi
6332 > rm -f conftest.err conftest.$ac_ext
6333 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6334 > echo "${ECHO_T}$ac_header_preproc" >&6
6335 >
6336 > # So?  What about this header?
6337 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6338 >  yes:no: )
6339 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6340 > echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6341 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6342 > echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6343 >    ac_header_preproc=yes
6344 >    ;;
6345 >  no:yes:* )
6346 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6347 > echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6348 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6349 > echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6350 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6351 > echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6352 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6353 > echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6354 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6355 > echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6356 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6357 > echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6358 >    (
6359 >      cat <<\_ASBOX
6360 > ## ------------------------------ ##
6361 > ## Report this to gezelter@nd.edu ##
6362 > ## ------------------------------ ##
6363 > _ASBOX
6364 >    ) |
6365 >      sed "s/^/$as_me: WARNING:     /" >&2
6366 >    ;;
6367 > esac
6368 > echo "$as_me:$LINENO: checking for fftw3.h" >&5
6369 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6370 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6371 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6372 > else
6373 >  ac_cv_header_fftw3_h=$ac_header_preproc
6374 > fi
6375 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6376 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6377 >
6378 > fi
6379 > if test $ac_cv_header_fftw3_h = yes; then
6380 >  fftw_cv_fftw3_h=yes
6381 > else
6382 >  fftw_cv_fftw3_h=no
6383 > fi
6384 >
6385 >
6386 >        if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"
6387 >        then
6388 >                echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6389 > echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6390 > if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6391 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6392 > else
6393 >  ac_check_lib_save_LIBS=$LIBS
6394 > LIBS="-lfftw  $LIBS"
6395 > cat >conftest.$ac_ext <<_ACEOF
6396 > /* confdefs.h.  */
6397 > _ACEOF
6398 > cat confdefs.h >>conftest.$ac_ext
6399 > cat >>conftest.$ac_ext <<_ACEOF
6400 > /* end confdefs.h.  */
6401 >
6402 > /* Override any gcc2 internal prototype to avoid an error.  */
6403 > #ifdef __cplusplus
6404 > extern "C"
6405 > #endif
6406 > /* We use char because int might match the return type of a gcc2
6407 >   builtin and then its argument prototype would still apply.  */
6408 > char fftwnd_one ();
6409 > #ifdef FC_DUMMY_MAIN
6410 > #ifndef FC_DUMMY_MAIN_EQ_F77
6411 > #  ifdef __cplusplus
6412 >     extern "C"
6413 > #  endif
6414 >   int FC_DUMMY_MAIN() { return 1; }
6415 > #endif
6416 > #endif
6417 > int
6418 > main ()
6419 > {
6420 > fftwnd_one ();
6421 >  ;
6422 >  return 0;
6423 > }
6424 > _ACEOF
6425 > rm -f conftest.$ac_objext conftest$ac_exeext
6426 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6427 >  (eval $ac_link) 2>conftest.er1
6428 >  ac_status=$?
6429 >  grep -v '^ *+' conftest.er1 >conftest.err
6430 >  rm -f conftest.er1
6431 >  cat conftest.err >&5
6432 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6433 >  (exit $ac_status); } &&
6434 >         { ac_try='test -z "$ac_c_werror_flag"
6435 >                         || test ! -s conftest.err'
6436 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6437 >  (eval $ac_try) 2>&5
6438 >  ac_status=$?
6439 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6440 >  (exit $ac_status); }; } &&
6441 >         { ac_try='test -s conftest$ac_exeext'
6442 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6443 >  (eval $ac_try) 2>&5
6444 >  ac_status=$?
6445 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6446 >  (exit $ac_status); }; }; then
6447 >  ac_cv_lib_fftw_fftwnd_one=yes
6448 > else
6449 >  echo "$as_me: failed program was:" >&5
6450 > sed 's/^/| /' conftest.$ac_ext >&5
6451 >
6452 > ac_cv_lib_fftw_fftwnd_one=no
6453 > fi
6454 > rm -f conftest.err conftest.$ac_objext \
6455 >      conftest$ac_exeext conftest.$ac_ext
6456 > LIBS=$ac_check_lib_save_LIBS
6457 > fi
6458 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6459 > echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6460 > if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6461 >  fftw_cv_libfftw=yes
6462 > else
6463 >  fftw_cv_libfftw=no
6464 > fi
6465 >
6466 >                if test "${ac_cv_header_fftw_h+set}" = set; then
6467 >  echo "$as_me:$LINENO: checking for fftw.h" >&5
6468 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6469 > if test "${ac_cv_header_fftw_h+set}" = set; then
6470 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6471 > fi
6472 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6473 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6474 > else
6475 >  # Is the header compilable?
6476 > echo "$as_me:$LINENO: checking fftw.h usability" >&5
6477 > echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6478 > cat >conftest.$ac_ext <<_ACEOF
6479 > /* confdefs.h.  */
6480 > _ACEOF
6481 > cat confdefs.h >>conftest.$ac_ext
6482 > cat >>conftest.$ac_ext <<_ACEOF
6483 > /* end confdefs.h.  */
6484 > $ac_includes_default
6485 > #include <fftw.h>
6486 > _ACEOF
6487 > rm -f conftest.$ac_objext
6488 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6489 >  (eval $ac_compile) 2>conftest.er1
6490 >  ac_status=$?
6491 >  grep -v '^ *+' conftest.er1 >conftest.err
6492 >  rm -f conftest.er1
6493 >  cat conftest.err >&5
6494 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6495 >  (exit $ac_status); } &&
6496 >         { ac_try='test -z "$ac_c_werror_flag"
6497 >                         || test ! -s conftest.err'
6498 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6499 >  (eval $ac_try) 2>&5
6500 >  ac_status=$?
6501 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6502 >  (exit $ac_status); }; } &&
6503 >         { ac_try='test -s conftest.$ac_objext'
6504 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6505 >  (eval $ac_try) 2>&5
6506 >  ac_status=$?
6507 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6508 >  (exit $ac_status); }; }; then
6509 >  ac_header_compiler=yes
6510 > else
6511 >  echo "$as_me: failed program was:" >&5
6512 > sed 's/^/| /' conftest.$ac_ext >&5
6513 >
6514 > ac_header_compiler=no
6515 > fi
6516 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6517 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6518 > echo "${ECHO_T}$ac_header_compiler" >&6
6519 >
6520 > # Is the header present?
6521 > echo "$as_me:$LINENO: checking fftw.h presence" >&5
6522 > echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6523 > cat >conftest.$ac_ext <<_ACEOF
6524 > /* confdefs.h.  */
6525 > _ACEOF
6526 > cat confdefs.h >>conftest.$ac_ext
6527 > cat >>conftest.$ac_ext <<_ACEOF
6528 > /* end confdefs.h.  */
6529 > #include <fftw.h>
6530 > _ACEOF
6531 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6532 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6533 >  ac_status=$?
6534 >  grep -v '^ *+' conftest.er1 >conftest.err
6535 >  rm -f conftest.er1
6536 >  cat conftest.err >&5
6537 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6538 >  (exit $ac_status); } >/dev/null; then
6539 >  if test -s conftest.err; then
6540 >    ac_cpp_err=$ac_c_preproc_warn_flag
6541 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6542 >  else
6543 >    ac_cpp_err=
6544 >  fi
6545 > else
6546 >  ac_cpp_err=yes
6547 > fi
6548 > if test -z "$ac_cpp_err"; then
6549 >  ac_header_preproc=yes
6550 > else
6551 >  echo "$as_me: failed program was:" >&5
6552 > sed 's/^/| /' conftest.$ac_ext >&5
6553 >
6554 >  ac_header_preproc=no
6555 > fi
6556 > rm -f conftest.err conftest.$ac_ext
6557 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6558 > echo "${ECHO_T}$ac_header_preproc" >&6
6559 >
6560 > # So?  What about this header?
6561 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6562 >  yes:no: )
6563 >    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6564 > echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6565 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6566 > echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6567 >    ac_header_preproc=yes
6568 >    ;;
6569 >  no:yes:* )
6570 >    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6571 > echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6572 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6573 > echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6574 >    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6575 > echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6576 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6577 > echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6578 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6579 > echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6580 >    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6581 > echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6582 >    (
6583 >      cat <<\_ASBOX
6584 > ## ------------------------------ ##
6585 > ## Report this to gezelter@nd.edu ##
6586 > ## ------------------------------ ##
6587 > _ASBOX
6588 >    ) |
6589 >      sed "s/^/$as_me: WARNING:     /" >&2
6590 >    ;;
6591 > esac
6592 > echo "$as_me:$LINENO: checking for fftw.h" >&5
6593 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6594 > if test "${ac_cv_header_fftw_h+set}" = set; then
6595 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6596 > else
6597 >  ac_cv_header_fftw_h=$ac_header_preproc
6598 > fi
6599 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6600 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6601 >
6602 > fi
6603 > if test $ac_cv_header_fftw_h = yes; then
6604 >  fftw_cv_fftw_h=yes
6605 > else
6606 >  fftw_cv_fftw_h=no
6607 > fi
6608 >
6609 >
6610 >                if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"
6611 >                then
6612 >                        echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6613 > echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6614 > if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6615 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6616 > else
6617 >  ac_check_lib_save_LIBS=$LIBS
6618 > LIBS="-ldfftw  $LIBS"
6619 > cat >conftest.$ac_ext <<_ACEOF
6620 > /* confdefs.h.  */
6621 > _ACEOF
6622 > cat confdefs.h >>conftest.$ac_ext
6623 > cat >>conftest.$ac_ext <<_ACEOF
6624 > /* end confdefs.h.  */
6625 >
6626 > /* Override any gcc2 internal prototype to avoid an error.  */
6627 > #ifdef __cplusplus
6628 > extern "C"
6629 > #endif
6630 > /* We use char because int might match the return type of a gcc2
6631 >   builtin and then its argument prototype would still apply.  */
6632 > char fftwnd_one ();
6633 > #ifdef FC_DUMMY_MAIN
6634 > #ifndef FC_DUMMY_MAIN_EQ_F77
6635 > #  ifdef __cplusplus
6636 >     extern "C"
6637 > #  endif
6638 >   int FC_DUMMY_MAIN() { return 1; }
6639 > #endif
6640 > #endif
6641 > int
6642 > main ()
6643 > {
6644 > fftwnd_one ();
6645 >  ;
6646 >  return 0;
6647 > }
6648 > _ACEOF
6649 > rm -f conftest.$ac_objext conftest$ac_exeext
6650 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6651 >  (eval $ac_link) 2>conftest.er1
6652 >  ac_status=$?
6653 >  grep -v '^ *+' conftest.er1 >conftest.err
6654 >  rm -f conftest.er1
6655 >  cat conftest.err >&5
6656 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6657 >  (exit $ac_status); } &&
6658 >         { ac_try='test -z "$ac_c_werror_flag"
6659 >                         || test ! -s conftest.err'
6660 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6661 >  (eval $ac_try) 2>&5
6662 >  ac_status=$?
6663 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6664 >  (exit $ac_status); }; } &&
6665 >         { ac_try='test -s conftest$ac_exeext'
6666 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6667 >  (eval $ac_try) 2>&5
6668 >  ac_status=$?
6669 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6670 >  (exit $ac_status); }; }; then
6671 >  ac_cv_lib_dfftw_fftwnd_one=yes
6672 > else
6673 >  echo "$as_me: failed program was:" >&5
6674 > sed 's/^/| /' conftest.$ac_ext >&5
6675 >
6676 > ac_cv_lib_dfftw_fftwnd_one=no
6677 > fi
6678 > rm -f conftest.err conftest.$ac_objext \
6679 >      conftest$ac_exeext conftest.$ac_ext
6680 > LIBS=$ac_check_lib_save_LIBS
6681 > fi
6682 > echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6683 > echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6684 > if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6685 >  fftw_cv_libdfftw=yes
6686 > else
6687 >  fftw_cv_libdfftw=no
6688 > fi
6689 >
6690 >                        if test "${ac_cv_header_dfftw_h+set}" = set; then
6691 >  echo "$as_me:$LINENO: checking for dfftw.h" >&5
6692 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6693 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6694 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6695 > fi
6696 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6697 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6698 > else
6699 >  # Is the header compilable?
6700 > echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6701 > echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6702 > cat >conftest.$ac_ext <<_ACEOF
6703 > /* confdefs.h.  */
6704 > _ACEOF
6705 > cat confdefs.h >>conftest.$ac_ext
6706 > cat >>conftest.$ac_ext <<_ACEOF
6707 > /* end confdefs.h.  */
6708 > $ac_includes_default
6709 > #include <dfftw.h>
6710 > _ACEOF
6711 > rm -f conftest.$ac_objext
6712 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6713 >  (eval $ac_compile) 2>conftest.er1
6714 >  ac_status=$?
6715 >  grep -v '^ *+' conftest.er1 >conftest.err
6716 >  rm -f conftest.er1
6717 >  cat conftest.err >&5
6718 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6719 >  (exit $ac_status); } &&
6720 >         { ac_try='test -z "$ac_c_werror_flag"
6721 >                         || test ! -s conftest.err'
6722 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6723 >  (eval $ac_try) 2>&5
6724 >  ac_status=$?
6725 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6726 >  (exit $ac_status); }; } &&
6727 >         { ac_try='test -s conftest.$ac_objext'
6728 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6729 >  (eval $ac_try) 2>&5
6730 >  ac_status=$?
6731 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6732 >  (exit $ac_status); }; }; then
6733 >  ac_header_compiler=yes
6734 > else
6735 >  echo "$as_me: failed program was:" >&5
6736 > sed 's/^/| /' conftest.$ac_ext >&5
6737 >
6738 > ac_header_compiler=no
6739 > fi
6740 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6741 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6742 > echo "${ECHO_T}$ac_header_compiler" >&6
6743 >
6744 > # Is the header present?
6745 > echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6746 > echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6747 > cat >conftest.$ac_ext <<_ACEOF
6748 > /* confdefs.h.  */
6749 > _ACEOF
6750 > cat confdefs.h >>conftest.$ac_ext
6751 > cat >>conftest.$ac_ext <<_ACEOF
6752 > /* end confdefs.h.  */
6753 > #include <dfftw.h>
6754 > _ACEOF
6755 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6756 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6757 >  ac_status=$?
6758 >  grep -v '^ *+' conftest.er1 >conftest.err
6759 >  rm -f conftest.er1
6760 >  cat conftest.err >&5
6761 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6762 >  (exit $ac_status); } >/dev/null; then
6763 >  if test -s conftest.err; then
6764 >    ac_cpp_err=$ac_c_preproc_warn_flag
6765 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6766 >  else
6767 >    ac_cpp_err=
6768 >  fi
6769 > else
6770 >  ac_cpp_err=yes
6771 > fi
6772 > if test -z "$ac_cpp_err"; then
6773 >  ac_header_preproc=yes
6774 > else
6775 >  echo "$as_me: failed program was:" >&5
6776 > sed 's/^/| /' conftest.$ac_ext >&5
6777 >
6778 >  ac_header_preproc=no
6779 > fi
6780 > rm -f conftest.err conftest.$ac_ext
6781 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6782 > echo "${ECHO_T}$ac_header_preproc" >&6
6783 >
6784 > # So?  What about this header?
6785 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6786 >  yes:no: )
6787 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6788 > echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6789 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6790 > echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6791 >    ac_header_preproc=yes
6792 >    ;;
6793 >  no:yes:* )
6794 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6795 > echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6796 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6797 > echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6798 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6799 > echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6800 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6801 > echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6802 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6803 > echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6804 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6805 > echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6806 >    (
6807 >      cat <<\_ASBOX
6808 > ## ------------------------------ ##
6809 > ## Report this to gezelter@nd.edu ##
6810 > ## ------------------------------ ##
6811 > _ASBOX
6812 >    ) |
6813 >      sed "s/^/$as_me: WARNING:     /" >&2
6814 >    ;;
6815 > esac
6816 > echo "$as_me:$LINENO: checking for dfftw.h" >&5
6817 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6818 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6819 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6820 > else
6821 >  ac_cv_header_dfftw_h=$ac_header_preproc
6822 > fi
6823 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6824 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6825 >
6826 > fi
6827 > if test $ac_cv_header_dfftw_h = yes; then
6828 >  fftw_cv_dfftw_h=yes
6829 > else
6830 >  fftw_cv_dfftw_h=no
6831 > fi
6832 >
6833 >
6834 >                fi
6835 >        fi
6836 >        ac_ext=c
6837 > ac_cpp='$CPP $CPPFLAGS'
6838 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6839 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6840 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6841 >
6842 >
6843 >        if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"
6844 >        then
6845 >
6846 > cat >>confdefs.h <<\_ACEOF
6847 > #define HAVE_FFTW3_H 1
6848 > _ACEOF
6849 >
6850 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6851 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6852 >                FFTW_LIBS="-lfftw3"
6853 >        else
6854 >        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"
6855 >        then
6856 >
6857 > cat >>confdefs.h <<\_ACEOF
6858 > #define HAVE_FFTW_H 1
6859 > _ACEOF
6860 >
6861 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6862 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6863 >                FFTW_LIBS="-lfftw"
6864 >        else
6865 >        if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"
6866 >        then
6867 >
6868 > cat >>confdefs.h <<\_ACEOF
6869 > #define HAVE_DFFTW_H 1
6870 > _ACEOF
6871 >
6872 >                FFTW_INC_DIR="${FFTW_HOME}/include"
6873 >                FFTW_LIB_DIR="${FFTW_HOME}/lib"
6874 >                FFTW_LIBS="-ldfftw"
6875 >        else
6876 >                echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6877 > echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6878 >                FFTW_INC_DIR=
6879 >                FFTW_LIB_DIR=
6880 >                FFTW_LIBS=
6881 >                LDFLAGS="$FFTW_OLD_LDFLAGS"
6882 >                CPPFLAGS="$FFTW_OLD_CPPFLAGS"
6883 >                echo "$as_me:$LINENO: result: failed" >&5
6884 > echo "${ECHO_T}failed" >&6
6885 >        echo ""
6886 >        echo "*********************************************************"
6887 >        echo "* WARNING: Could not find a working FFTW installation   *"
6888 >        echo "* If you need the staticProps program to be able to     *"
6889 >        echo "* compute undulation spectra, be sure to specify a      *"
6890 >        echo "* valid fftw installation with --with-fftw=DIR          *"
6891 >        echo "*                                                       *"
6892 >        echo "* OOPSE will still work without fftw installed.         *"
6893 >        echo "*********************************************************"
6894 >        echo ""
6895 >        fi
6896 >        fi
6897 >        fi
6898 >
6899 >
6900 >
6901 > fi
6902 > fi
6903 >
6904 >
6905 >
6906 > # Checks for header files.
6907 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6908 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6909 > if test "${ac_cv_header_stdc+set}" = set; then
6910 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6911 > else
6912 >  cat >conftest.$ac_ext <<_ACEOF
6913 > /* confdefs.h.  */
6914 > _ACEOF
6915 > cat confdefs.h >>conftest.$ac_ext
6916 > cat >>conftest.$ac_ext <<_ACEOF
6917 > /* end confdefs.h.  */
6918 > #include <stdlib.h>
6919 > #include <stdarg.h>
6920 > #include <string.h>
6921 > #include <float.h>
6922 >
6923 > #ifdef FC_DUMMY_MAIN
6924 > #ifndef FC_DUMMY_MAIN_EQ_F77
6925 > #  ifdef __cplusplus
6926 >     extern "C"
6927 > #  endif
6928 >   int FC_DUMMY_MAIN() { return 1; }
6929 > #endif
6930 > #endif
6931 > int
6932 > main ()
6933 > {
6934 >
6935 >  ;
6936 >  return 0;
6937 > }
6938 > _ACEOF
6939 > rm -f conftest.$ac_objext
6940 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6941 >  (eval $ac_compile) 2>conftest.er1
6942 >  ac_status=$?
6943 >  grep -v '^ *+' conftest.er1 >conftest.err
6944 >  rm -f conftest.er1
6945 >  cat conftest.err >&5
6946 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6947 >  (exit $ac_status); } &&
6948 >         { ac_try='test -z "$ac_c_werror_flag"
6949 >                         || test ! -s conftest.err'
6950 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6951 >  (eval $ac_try) 2>&5
6952 >  ac_status=$?
6953 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6954 >  (exit $ac_status); }; } &&
6955 >         { ac_try='test -s conftest.$ac_objext'
6956 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6957 >  (eval $ac_try) 2>&5
6958 >  ac_status=$?
6959 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6960 >  (exit $ac_status); }; }; then
6961 >  ac_cv_header_stdc=yes
6962 > else
6963 >  echo "$as_me: failed program was:" >&5
6964 > sed 's/^/| /' conftest.$ac_ext >&5
6965 >
6966 > ac_cv_header_stdc=no
6967 > fi
6968 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6969 >
6970 > if test $ac_cv_header_stdc = yes; then
6971 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6972 >  cat >conftest.$ac_ext <<_ACEOF
6973 > /* confdefs.h.  */
6974 > _ACEOF
6975 > cat confdefs.h >>conftest.$ac_ext
6976 > cat >>conftest.$ac_ext <<_ACEOF
6977 > /* end confdefs.h.  */
6978 > #include <string.h>
6979 >
6980 > _ACEOF
6981 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6982 >  $EGREP "memchr" >/dev/null 2>&1; then
6983 >  :
6984 > else
6985 >  ac_cv_header_stdc=no
6986 > fi
6987 > rm -f conftest*
6988 >
6989 > fi
6990 >
6991 > if test $ac_cv_header_stdc = yes; then
6992 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
6993 >  cat >conftest.$ac_ext <<_ACEOF
6994 > /* confdefs.h.  */
6995 > _ACEOF
6996 > cat confdefs.h >>conftest.$ac_ext
6997 > cat >>conftest.$ac_ext <<_ACEOF
6998 > /* end confdefs.h.  */
6999 > #include <stdlib.h>
7000 >
7001 > _ACEOF
7002 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7003 >  $EGREP "free" >/dev/null 2>&1; then
7004 >  :
7005 > else
7006 >  ac_cv_header_stdc=no
7007 > fi
7008 > rm -f conftest*
7009 >
7010 > fi
7011 >
7012 > if test $ac_cv_header_stdc = yes; then
7013 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7014 >  if test "$cross_compiling" = yes; then
7015 >  :
7016 > else
7017 >  cat >conftest.$ac_ext <<_ACEOF
7018 > /* confdefs.h.  */
7019 > _ACEOF
7020 > cat confdefs.h >>conftest.$ac_ext
7021 > cat >>conftest.$ac_ext <<_ACEOF
7022 > /* end confdefs.h.  */
7023 > #include <ctype.h>
7024 > #if ((' ' & 0x0FF) == 0x020)
7025 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7026 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7027 > #else
7028 > # define ISLOWER(c) \
7029 >                   (('a' <= (c) && (c) <= 'i') \
7030 >                     || ('j' <= (c) && (c) <= 'r') \
7031 >                     || ('s' <= (c) && (c) <= 'z'))
7032 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7033 > #endif
7034 >
7035 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7036 > int
7037 > main ()
7038 > {
7039 >  int i;
7040 >  for (i = 0; i < 256; i++)
7041 >    if (XOR (islower (i), ISLOWER (i))
7042 >        || toupper (i) != TOUPPER (i))
7043 >      exit(2);
7044 >  exit (0);
7045 > }
7046 > _ACEOF
7047 > rm -f conftest$ac_exeext
7048 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7049 >  (eval $ac_link) 2>&5
7050 >  ac_status=$?
7051 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7052 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7053 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7054 >  (eval $ac_try) 2>&5
7055 >  ac_status=$?
7056 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7057 >  (exit $ac_status); }; }; then
7058 >  :
7059 > else
7060 >  echo "$as_me: program exited with status $ac_status" >&5
7061 > echo "$as_me: failed program was:" >&5
7062 > sed 's/^/| /' conftest.$ac_ext >&5
7063 >
7064 > ( exit $ac_status )
7065 > ac_cv_header_stdc=no
7066 > fi
7067 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7068 > fi
7069 > fi
7070 > fi
7071 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7072 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7073 > if test $ac_cv_header_stdc = yes; then
7074 >
7075 > cat >>confdefs.h <<\_ACEOF
7076 > #define STDC_HEADERS 1
7077 > _ACEOF
7078 >
7079 > fi
7080 >
7081 >
7082 >
7083 >
7084 >
7085 >
7086 >
7087 >
7088 >
7089 >
7090 >
7091 >
7092 >
7093 >
7094 >
7095 >
7096 >
7097 >
7098 >
7099 >
7100 >
7101 >
7102 >
7103 >
7104 >
7105 >
7106 > 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
7107 > do
7108 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7109 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7110 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7111 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7112 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7113 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7114 > fi
7115 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7116 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7117 > else
7118 >  # Is the header compilable?
7119 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7120 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7121 > cat >conftest.$ac_ext <<_ACEOF
7122 > /* confdefs.h.  */
7123 > _ACEOF
7124 > cat confdefs.h >>conftest.$ac_ext
7125 > cat >>conftest.$ac_ext <<_ACEOF
7126 > /* end confdefs.h.  */
7127 > $ac_includes_default
7128 > #include <$ac_header>
7129 > _ACEOF
7130 > rm -f conftest.$ac_objext
7131 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7132 >  (eval $ac_compile) 2>conftest.er1
7133 >  ac_status=$?
7134 >  grep -v '^ *+' conftest.er1 >conftest.err
7135 >  rm -f conftest.er1
7136 >  cat conftest.err >&5
7137 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7138 >  (exit $ac_status); } &&
7139 >         { ac_try='test -z "$ac_c_werror_flag"
7140 >                         || test ! -s conftest.err'
7141 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7142 >  (eval $ac_try) 2>&5
7143 >  ac_status=$?
7144 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7145 >  (exit $ac_status); }; } &&
7146 >         { ac_try='test -s conftest.$ac_objext'
7147 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7148 >  (eval $ac_try) 2>&5
7149 >  ac_status=$?
7150 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7151 >  (exit $ac_status); }; }; then
7152 >  ac_header_compiler=yes
7153 > else
7154 >  echo "$as_me: failed program was:" >&5
7155 > sed 's/^/| /' conftest.$ac_ext >&5
7156 >
7157 > ac_header_compiler=no
7158 > fi
7159 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7160 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7161 > echo "${ECHO_T}$ac_header_compiler" >&6
7162 >
7163 > # Is the header present?
7164 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7165 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7166 > cat >conftest.$ac_ext <<_ACEOF
7167 > /* confdefs.h.  */
7168 > _ACEOF
7169 > cat confdefs.h >>conftest.$ac_ext
7170 > cat >>conftest.$ac_ext <<_ACEOF
7171 > /* end confdefs.h.  */
7172 > #include <$ac_header>
7173 > _ACEOF
7174 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7175 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7176 >  ac_status=$?
7177 >  grep -v '^ *+' conftest.er1 >conftest.err
7178 >  rm -f conftest.er1
7179 >  cat conftest.err >&5
7180 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7181 >  (exit $ac_status); } >/dev/null; then
7182 >  if test -s conftest.err; then
7183 >    ac_cpp_err=$ac_c_preproc_warn_flag
7184 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7185 >  else
7186 >    ac_cpp_err=
7187 >  fi
7188 > else
7189 >  ac_cpp_err=yes
7190 > fi
7191 > if test -z "$ac_cpp_err"; then
7192 >  ac_header_preproc=yes
7193 > else
7194 >  echo "$as_me: failed program was:" >&5
7195 > sed 's/^/| /' conftest.$ac_ext >&5
7196 >
7197 >  ac_header_preproc=no
7198 > fi
7199 > rm -f conftest.err conftest.$ac_ext
7200 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7201 > echo "${ECHO_T}$ac_header_preproc" >&6
7202 >
7203 > # So?  What about this header?
7204 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7205 >  yes:no: )
7206 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7207 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7208 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7209 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7210 >    ac_header_preproc=yes
7211 >    ;;
7212 >  no:yes:* )
7213 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7214 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7215 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7216 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7217 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7218 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7219 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7220 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7221 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7222 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7223 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7224 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7225 >    (
7226 >      cat <<\_ASBOX
7227 > ## ------------------------------ ##
7228 > ## Report this to gezelter@nd.edu ##
7229 > ## ------------------------------ ##
7230 > _ASBOX
7231 >    ) |
7232 >      sed "s/^/$as_me: WARNING:     /" >&2
7233 >    ;;
7234 > esac
7235 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7236 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7237 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7238 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7239 > else
7240 >  eval "$as_ac_Header=\$ac_header_preproc"
7241 > fi
7242 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7243 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7244 >
7245 > fi
7246 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7247 >  cat >>confdefs.h <<_ACEOF
7248 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7249 > _ACEOF
7250 >
7251 > fi
7252 >
7253 > done
7254 >
7255 >
7256 > # Checks for typedefs, structures, and compiler characteristics.
7257 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7258 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7259 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7260 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7261 > else
7262 >  cat >conftest.$ac_ext <<_ACEOF
7263 > /* confdefs.h.  */
7264 > _ACEOF
7265 > cat confdefs.h >>conftest.$ac_ext
7266 > cat >>conftest.$ac_ext <<_ACEOF
7267 > /* end confdefs.h.  */
7268 >
7269 > #include <stdbool.h>
7270 > #ifndef bool
7271 > # error bool is not defined
7272 > #endif
7273 > #ifndef false
7274 > # error false is not defined
7275 > #endif
7276 > #if false
7277 > # error false is not 0
7278 > #endif
7279 > #ifndef true
7280 > # error true is not defined
7281 > #endif
7282 > #if true != 1
7283 > # error true is not 1
7284 > #endif
7285 > #ifndef __bool_true_false_are_defined
7286 > # error __bool_true_false_are_defined is not defined
7287 > #endif
7288 >
7289 >        struct s { _Bool s: 1; _Bool t; } s;
7290 >
7291 >        char a[true == 1 ? 1 : -1];
7292 >        char b[false == 0 ? 1 : -1];
7293 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7294 >        char d[(bool) -0.5 == true ? 1 : -1];
7295 >        bool e = &s;
7296 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7297 >        char g[true];
7298 >        char h[sizeof (_Bool)];
7299 >        char i[sizeof s.t];
7300 >
7301 > #ifdef FC_DUMMY_MAIN
7302 > #ifndef FC_DUMMY_MAIN_EQ_F77
7303 > #  ifdef __cplusplus
7304 >     extern "C"
7305 > #  endif
7306 >   int FC_DUMMY_MAIN() { return 1; }
7307 > #endif
7308 > #endif
7309 > int
7310 > main ()
7311 > {
7312 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7313 >  ;
7314 >  return 0;
7315 > }
7316 > _ACEOF
7317 > rm -f conftest.$ac_objext
7318 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7319 >  (eval $ac_compile) 2>conftest.er1
7320 >  ac_status=$?
7321 >  grep -v '^ *+' conftest.er1 >conftest.err
7322 >  rm -f conftest.er1
7323 >  cat conftest.err >&5
7324 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7325 >  (exit $ac_status); } &&
7326 >         { ac_try='test -z "$ac_c_werror_flag"
7327 >                         || test ! -s conftest.err'
7328 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7329 >  (eval $ac_try) 2>&5
7330 >  ac_status=$?
7331 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7332 >  (exit $ac_status); }; } &&
7333 >         { ac_try='test -s conftest.$ac_objext'
7334 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7335 >  (eval $ac_try) 2>&5
7336 >  ac_status=$?
7337 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7338 >  (exit $ac_status); }; }; then
7339 >  ac_cv_header_stdbool_h=yes
7340 > else
7341 >  echo "$as_me: failed program was:" >&5
7342 > sed 's/^/| /' conftest.$ac_ext >&5
7343 >
7344 > ac_cv_header_stdbool_h=no
7345 > fi
7346 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7347 > fi
7348 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7349 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7350 > echo "$as_me:$LINENO: checking for _Bool" >&5
7351 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7352 > if test "${ac_cv_type__Bool+set}" = set; then
7353 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7354 > else
7355 >  cat >conftest.$ac_ext <<_ACEOF
7356 > /* confdefs.h.  */
7357 > _ACEOF
7358 > cat confdefs.h >>conftest.$ac_ext
7359 > cat >>conftest.$ac_ext <<_ACEOF
7360 > /* end confdefs.h.  */
7361 > $ac_includes_default
7362 > #ifdef FC_DUMMY_MAIN
7363 > #ifndef FC_DUMMY_MAIN_EQ_F77
7364 > #  ifdef __cplusplus
7365 >     extern "C"
7366 > #  endif
7367 >   int FC_DUMMY_MAIN() { return 1; }
7368 > #endif
7369 > #endif
7370 > int
7371 > main ()
7372 > {
7373 > if ((_Bool *) 0)
7374 >  return 0;
7375 > if (sizeof (_Bool))
7376 >  return 0;
7377 >  ;
7378 >  return 0;
7379 > }
7380 > _ACEOF
7381 > rm -f conftest.$ac_objext
7382 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7383 >  (eval $ac_compile) 2>conftest.er1
7384 >  ac_status=$?
7385 >  grep -v '^ *+' conftest.er1 >conftest.err
7386 >  rm -f conftest.er1
7387 >  cat conftest.err >&5
7388 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7389 >  (exit $ac_status); } &&
7390 >         { ac_try='test -z "$ac_c_werror_flag"
7391 >                         || test ! -s conftest.err'
7392 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7393 >  (eval $ac_try) 2>&5
7394 >  ac_status=$?
7395 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7396 >  (exit $ac_status); }; } &&
7397 >         { ac_try='test -s conftest.$ac_objext'
7398 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7399 >  (eval $ac_try) 2>&5
7400 >  ac_status=$?
7401 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7402 >  (exit $ac_status); }; }; then
7403 >  ac_cv_type__Bool=yes
7404 > else
7405 >  echo "$as_me: failed program was:" >&5
7406 > sed 's/^/| /' conftest.$ac_ext >&5
7407 >
7408 > ac_cv_type__Bool=no
7409 > fi
7410 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7411 > fi
7412 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7413 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7414 > if test $ac_cv_type__Bool = yes; then
7415 >
7416 > cat >>confdefs.h <<_ACEOF
7417 > #define HAVE__BOOL 1
7418 > _ACEOF
7419 >
7420 >
7421 > fi
7422 >
7423 > if test $ac_cv_header_stdbool_h = yes; then
7424 >
7425 > cat >>confdefs.h <<\_ACEOF
7426 > #define HAVE_STDBOOL_H 1
7427 > _ACEOF
7428 >
7429 > fi
7430 >
7431 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7432 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7433 > if test "${ac_cv_c_const+set}" = set; then
7434 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7435 > else
7436 >  cat >conftest.$ac_ext <<_ACEOF
7437 > /* confdefs.h.  */
7438 > _ACEOF
7439 > cat confdefs.h >>conftest.$ac_ext
7440 > cat >>conftest.$ac_ext <<_ACEOF
7441 > /* end confdefs.h.  */
7442 >
7443 > #ifdef FC_DUMMY_MAIN
7444 > #ifndef FC_DUMMY_MAIN_EQ_F77
7445 > #  ifdef __cplusplus
7446 >     extern "C"
7447 > #  endif
7448 >   int FC_DUMMY_MAIN() { return 1; }
7449 > #endif
7450 > #endif
7451 > int
7452 > main ()
7453 > {
7454 > /* FIXME: Include the comments suggested by Paul. */
7455 > #ifndef __cplusplus
7456 >  /* Ultrix mips cc rejects this.  */
7457 >  typedef int charset[2];
7458 >  const charset x;
7459 >  /* SunOS 4.1.1 cc rejects this.  */
7460 >  char const *const *ccp;
7461 >  char **p;
7462 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7463 >  struct point {int x, y;};
7464 >  static struct point const zero = {0,0};
7465 >  /* AIX XL C 1.02.0.0 rejects this.
7466 >     It does not let you subtract one const X* pointer from another in
7467 >     an arm of an if-expression whose if-part is not a constant
7468 >     expression */
7469 >  const char *g = "string";
7470 >  ccp = &g + (g ? g-g : 0);
7471 >  /* HPUX 7.0 cc rejects these. */
7472 >  ++ccp;
7473 >  p = (char**) ccp;
7474 >  ccp = (char const *const *) p;
7475 >  { /* SCO 3.2v4 cc rejects this.  */
7476 >    char *t;
7477 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7478 >
7479 >    *t++ = 0;
7480 >  }
7481 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7482 >    int x[] = {25, 17};
7483 >    const int *foo = &x[0];
7484 >    ++foo;
7485 >  }
7486 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7487 >    typedef const int *iptr;
7488 >    iptr p = 0;
7489 >    ++p;
7490 >  }
7491 >  { /* AIX XL C 1.02.0.0 rejects this saying
7492 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7493 >    struct s { int j; const int *ap[3]; };
7494 >    struct s *b; b->j = 5;
7495 >  }
7496 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7497 >    const int foo = 10;
7498 >  }
7499 > #endif
7500 >
7501 >  ;
7502 >  return 0;
7503 > }
7504 > _ACEOF
7505 > rm -f conftest.$ac_objext
7506 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7507 >  (eval $ac_compile) 2>conftest.er1
7508 >  ac_status=$?
7509 >  grep -v '^ *+' conftest.er1 >conftest.err
7510 >  rm -f conftest.er1
7511 >  cat conftest.err >&5
7512 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7513 >  (exit $ac_status); } &&
7514 >         { ac_try='test -z "$ac_c_werror_flag"
7515 >                         || test ! -s conftest.err'
7516 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7517 >  (eval $ac_try) 2>&5
7518 >  ac_status=$?
7519 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7520 >  (exit $ac_status); }; } &&
7521 >         { ac_try='test -s conftest.$ac_objext'
7522 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7523 >  (eval $ac_try) 2>&5
7524 >  ac_status=$?
7525 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7526 >  (exit $ac_status); }; }; then
7527 >  ac_cv_c_const=yes
7528 > else
7529 >  echo "$as_me: failed program was:" >&5
7530 > sed 's/^/| /' conftest.$ac_ext >&5
7531 >
7532 > ac_cv_c_const=no
7533 > fi
7534 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7535 > fi
7536 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7537 > echo "${ECHO_T}$ac_cv_c_const" >&6
7538 > if test $ac_cv_c_const = no; then
7539 >
7540 > cat >>confdefs.h <<\_ACEOF
7541 > #define const
7542 > _ACEOF
7543 >
7544 > fi
7545 >
7546 > echo "$as_me:$LINENO: checking for inline" >&5
7547 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7548 > if test "${ac_cv_c_inline+set}" = set; then
7549 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7550 > else
7551 >  ac_cv_c_inline=no
7552 > for ac_kw in inline __inline__ __inline; do
7553 >  cat >conftest.$ac_ext <<_ACEOF
7554 > /* confdefs.h.  */
7555 > _ACEOF
7556 > cat confdefs.h >>conftest.$ac_ext
7557 > cat >>conftest.$ac_ext <<_ACEOF
7558 > /* end confdefs.h.  */
7559 > #ifndef __cplusplus
7560 > typedef int foo_t;
7561 > static $ac_kw foo_t static_foo () {return 0; }
7562 > $ac_kw foo_t foo () {return 0; }
7563 > #endif
7564 >
7565 > _ACEOF
7566 > rm -f conftest.$ac_objext
7567 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7568 >  (eval $ac_compile) 2>conftest.er1
7569 >  ac_status=$?
7570 >  grep -v '^ *+' conftest.er1 >conftest.err
7571 >  rm -f conftest.er1
7572 >  cat conftest.err >&5
7573 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7574 >  (exit $ac_status); } &&
7575 >         { ac_try='test -z "$ac_c_werror_flag"
7576 >                         || test ! -s conftest.err'
7577 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7578 >  (eval $ac_try) 2>&5
7579 >  ac_status=$?
7580 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7581 >  (exit $ac_status); }; } &&
7582 >         { ac_try='test -s conftest.$ac_objext'
7583 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7584 >  (eval $ac_try) 2>&5
7585 >  ac_status=$?
7586 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7587 >  (exit $ac_status); }; }; then
7588 >  ac_cv_c_inline=$ac_kw; break
7589 > else
7590 >  echo "$as_me: failed program was:" >&5
7591 > sed 's/^/| /' conftest.$ac_ext >&5
7592 >
7593 > fi
7594 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7595 > done
7596 >
7597 > fi
7598 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7599 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7600 >
7601 >
7602 > case $ac_cv_c_inline in
7603 >  inline | yes) ;;
7604 >  *)
7605 >    case $ac_cv_c_inline in
7606 >      no) ac_val=;;
7607 >      *) ac_val=$ac_cv_c_inline;;
7608 >    esac
7609 >    cat >>confdefs.h <<_ACEOF
7610 > #ifndef __cplusplus
7611 > #define inline $ac_val
7612 > #endif
7613 > _ACEOF
7614 >    ;;
7615 > esac
7616 >
7617 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7618 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7619 > if test "${ac_cv_c_restrict+set}" = set; then
7620 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7621 > else
7622 >  ac_cv_c_restrict=no
7623 >   # Try the official restrict keyword, then gcc's __restrict, and
7624 >   # the less common variants.
7625 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
7626 >     cat >conftest.$ac_ext <<_ACEOF
7627 > /* confdefs.h.  */
7628 > _ACEOF
7629 > cat confdefs.h >>conftest.$ac_ext
7630 > cat >>conftest.$ac_ext <<_ACEOF
7631 > /* end confdefs.h.  */
7632 > float * $ac_kw x;
7633 > _ACEOF
7634 > rm -f conftest.$ac_objext
7635 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7636 >  (eval $ac_compile) 2>conftest.er1
7637 >  ac_status=$?
7638 >  grep -v '^ *+' conftest.er1 >conftest.err
7639 >  rm -f conftest.er1
7640 >  cat conftest.err >&5
7641 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7642 >  (exit $ac_status); } &&
7643 >         { ac_try='test -z "$ac_c_werror_flag"
7644 >                         || test ! -s conftest.err'
7645 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7646 >  (eval $ac_try) 2>&5
7647 >  ac_status=$?
7648 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7649 >  (exit $ac_status); }; } &&
7650 >         { ac_try='test -s conftest.$ac_objext'
7651 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7652 >  (eval $ac_try) 2>&5
7653 >  ac_status=$?
7654 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7655 >  (exit $ac_status); }; }; then
7656 >  ac_cv_c_restrict=$ac_kw; break
7657 > else
7658 >  echo "$as_me: failed program was:" >&5
7659 > sed 's/^/| /' conftest.$ac_ext >&5
7660 >
7661 > fi
7662 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7663 >   done
7664 >
7665 > fi
7666 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7667 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
7668 > case $ac_cv_c_restrict in
7669 >   restrict) ;;
7670 >   no)
7671 > cat >>confdefs.h <<\_ACEOF
7672 > #define restrict
7673 > _ACEOF
7674 > ;;
7675 >   *)  cat >>confdefs.h <<_ACEOF
7676 > #define restrict $ac_cv_c_restrict
7677 > _ACEOF
7678 > ;;
7679 > esac
7680 >
7681 > echo "$as_me:$LINENO: checking for size_t" >&5
7682 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
7683 > if test "${ac_cv_type_size_t+set}" = set; then
7684 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7685 > else
7686 >  cat >conftest.$ac_ext <<_ACEOF
7687 > /* confdefs.h.  */
7688 > _ACEOF
7689 > cat confdefs.h >>conftest.$ac_ext
7690 > cat >>conftest.$ac_ext <<_ACEOF
7691 > /* end confdefs.h.  */
7692 > $ac_includes_default
7693 > #ifdef FC_DUMMY_MAIN
7694 > #ifndef FC_DUMMY_MAIN_EQ_F77
7695 > #  ifdef __cplusplus
7696 >     extern "C"
7697 > #  endif
7698 >   int FC_DUMMY_MAIN() { return 1; }
7699 > #endif
7700 > #endif
7701 > int
7702 > main ()
7703 > {
7704 > if ((size_t *) 0)
7705 >  return 0;
7706 > if (sizeof (size_t))
7707 >  return 0;
7708 >  ;
7709 >  return 0;
7710 > }
7711 > _ACEOF
7712 > rm -f conftest.$ac_objext
7713 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7714 >  (eval $ac_compile) 2>conftest.er1
7715 >  ac_status=$?
7716 >  grep -v '^ *+' conftest.er1 >conftest.err
7717 >  rm -f conftest.er1
7718 >  cat conftest.err >&5
7719 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7720 >  (exit $ac_status); } &&
7721 >         { ac_try='test -z "$ac_c_werror_flag"
7722 >                         || test ! -s conftest.err'
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); }; } &&
7728 >         { ac_try='test -s conftest.$ac_objext'
7729 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7730 >  (eval $ac_try) 2>&5
7731 >  ac_status=$?
7732 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7733 >  (exit $ac_status); }; }; then
7734 >  ac_cv_type_size_t=yes
7735 > else
7736 >  echo "$as_me: failed program was:" >&5
7737 > sed 's/^/| /' conftest.$ac_ext >&5
7738 >
7739 > ac_cv_type_size_t=no
7740 > fi
7741 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7742 > fi
7743 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
7744 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
7745 > if test $ac_cv_type_size_t = yes; then
7746 >  :
7747 > else
7748 >
7749 > cat >>confdefs.h <<_ACEOF
7750 > #define size_t unsigned
7751 > _ACEOF
7752 >
7753 > fi
7754 >
7755 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
7756 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
7757 > if test "${ac_cv_header_time+set}" = set; then
7758 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7759 > else
7760 >  cat >conftest.$ac_ext <<_ACEOF
7761 > /* confdefs.h.  */
7762 > _ACEOF
7763 > cat confdefs.h >>conftest.$ac_ext
7764 > cat >>conftest.$ac_ext <<_ACEOF
7765 > /* end confdefs.h.  */
7766 > #include <sys/types.h>
7767 > #include <sys/time.h>
7768 > #include <time.h>
7769 >
7770 > #ifdef FC_DUMMY_MAIN
7771 > #ifndef FC_DUMMY_MAIN_EQ_F77
7772 > #  ifdef __cplusplus
7773 >     extern "C"
7774 > #  endif
7775 >   int FC_DUMMY_MAIN() { return 1; }
7776 > #endif
7777 > #endif
7778 > int
7779 > main ()
7780 > {
7781 > if ((struct tm *) 0)
7782 > return 0;
7783 >  ;
7784 >  return 0;
7785 > }
7786 > _ACEOF
7787 > rm -f conftest.$ac_objext
7788 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7789 >  (eval $ac_compile) 2>conftest.er1
7790 >  ac_status=$?
7791 >  grep -v '^ *+' conftest.er1 >conftest.err
7792 >  rm -f conftest.er1
7793 >  cat conftest.err >&5
7794 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7795 >  (exit $ac_status); } &&
7796 >         { ac_try='test -z "$ac_c_werror_flag"
7797 >                         || test ! -s conftest.err'
7798 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7799 >  (eval $ac_try) 2>&5
7800 >  ac_status=$?
7801 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7802 >  (exit $ac_status); }; } &&
7803 >         { ac_try='test -s conftest.$ac_objext'
7804 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7805 >  (eval $ac_try) 2>&5
7806 >  ac_status=$?
7807 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7808 >  (exit $ac_status); }; }; then
7809 >  ac_cv_header_time=yes
7810 > else
7811 >  echo "$as_me: failed program was:" >&5
7812 > sed 's/^/| /' conftest.$ac_ext >&5
7813 >
7814 > ac_cv_header_time=no
7815 > fi
7816 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7817 > fi
7818 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7819 > echo "${ECHO_T}$ac_cv_header_time" >&6
7820 > if test $ac_cv_header_time = yes; then
7821 >
7822 > cat >>confdefs.h <<\_ACEOF
7823 > #define TIME_WITH_SYS_TIME 1
7824 > _ACEOF
7825 >
7826 > fi
7827 >
7828 > echo "$as_me:$LINENO: checking for clock_t" >&5
7829 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7830 > if test "${ac_cv_type_clock_t+set}" = set; then
7831 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7832 > else
7833 >  cat >conftest.$ac_ext <<_ACEOF
7834 > /* confdefs.h.  */
7835 > _ACEOF
7836 > cat confdefs.h >>conftest.$ac_ext
7837 > cat >>conftest.$ac_ext <<_ACEOF
7838 > /* end confdefs.h.  */
7839 > $ac_includes_default
7840 > #ifdef FC_DUMMY_MAIN
7841 > #ifndef FC_DUMMY_MAIN_EQ_F77
7842 > #  ifdef __cplusplus
7843 >     extern "C"
7844 > #  endif
7845 >   int FC_DUMMY_MAIN() { return 1; }
7846 > #endif
7847 > #endif
7848 > int
7849 > main ()
7850 > {
7851 > if ((clock_t *) 0)
7852 >  return 0;
7853 > if (sizeof (clock_t))
7854 >  return 0;
7855 >  ;
7856 >  return 0;
7857 > }
7858 > _ACEOF
7859 > rm -f conftest.$ac_objext
7860 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7861 >  (eval $ac_compile) 2>conftest.er1
7862 >  ac_status=$?
7863 >  grep -v '^ *+' conftest.er1 >conftest.err
7864 >  rm -f conftest.er1
7865 >  cat conftest.err >&5
7866 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7867 >  (exit $ac_status); } &&
7868 >         { ac_try='test -z "$ac_c_werror_flag"
7869 >                         || test ! -s conftest.err'
7870 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7871 >  (eval $ac_try) 2>&5
7872 >  ac_status=$?
7873 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7874 >  (exit $ac_status); }; } &&
7875 >         { ac_try='test -s conftest.$ac_objext'
7876 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7877 >  (eval $ac_try) 2>&5
7878 >  ac_status=$?
7879 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7880 >  (exit $ac_status); }; }; then
7881 >  ac_cv_type_clock_t=yes
7882 > else
7883 >  echo "$as_me: failed program was:" >&5
7884 > sed 's/^/| /' conftest.$ac_ext >&5
7885 >
7886 > ac_cv_type_clock_t=no
7887 > fi
7888 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7889 > fi
7890 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7891 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7892 > if test $ac_cv_type_clock_t = yes; then
7893 >
7894 > cat >>confdefs.h <<_ACEOF
7895 > #define HAVE_CLOCK_T 1
7896 > _ACEOF
7897 >
7898 >
7899 > fi
7900 >
7901 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7902 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7903 > if test "${ac_cv_c_const+set}" = set; then
7904 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7905 > else
7906 >  cat >conftest.$ac_ext <<_ACEOF
7907 > /* confdefs.h.  */
7908 > _ACEOF
7909 > cat confdefs.h >>conftest.$ac_ext
7910 > cat >>conftest.$ac_ext <<_ACEOF
7911 > /* end confdefs.h.  */
7912 >
7913 > #ifdef FC_DUMMY_MAIN
7914 > #ifndef FC_DUMMY_MAIN_EQ_F77
7915 > #  ifdef __cplusplus
7916 >     extern "C"
7917 > #  endif
7918 >   int FC_DUMMY_MAIN() { return 1; }
7919 > #endif
7920 > #endif
7921 > int
7922 > main ()
7923 > {
7924 > /* FIXME: Include the comments suggested by Paul. */
7925 > #ifndef __cplusplus
7926 >  /* Ultrix mips cc rejects this.  */
7927 >  typedef int charset[2];
7928 >  const charset x;
7929 >  /* SunOS 4.1.1 cc rejects this.  */
7930 >  char const *const *ccp;
7931 >  char **p;
7932 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7933 >  struct point {int x, y;};
7934 >  static struct point const zero = {0,0};
7935 >  /* AIX XL C 1.02.0.0 rejects this.
7936 >     It does not let you subtract one const X* pointer from another in
7937 >     an arm of an if-expression whose if-part is not a constant
7938 >     expression */
7939 >  const char *g = "string";
7940 >  ccp = &g + (g ? g-g : 0);
7941 >  /* HPUX 7.0 cc rejects these. */
7942 >  ++ccp;
7943 >  p = (char**) ccp;
7944 >  ccp = (char const *const *) p;
7945 >  { /* SCO 3.2v4 cc rejects this.  */
7946 >    char *t;
7947 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7948 >
7949 >    *t++ = 0;
7950 >  }
7951 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7952 >    int x[] = {25, 17};
7953 >    const int *foo = &x[0];
7954 >    ++foo;
7955 >  }
7956 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7957 >    typedef const int *iptr;
7958 >    iptr p = 0;
7959 >    ++p;
7960 >  }
7961 >  { /* AIX XL C 1.02.0.0 rejects this saying
7962 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7963 >    struct s { int j; const int *ap[3]; };
7964 >    struct s *b; b->j = 5;
7965 >  }
7966 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7967 >    const int foo = 10;
7968 >  }
7969 > #endif
7970 >
7971 >  ;
7972 >  return 0;
7973 > }
7974 > _ACEOF
7975 > rm -f conftest.$ac_objext
7976 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7977 >  (eval $ac_compile) 2>conftest.er1
7978 >  ac_status=$?
7979 >  grep -v '^ *+' conftest.er1 >conftest.err
7980 >  rm -f conftest.er1
7981 >  cat conftest.err >&5
7982 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7983 >  (exit $ac_status); } &&
7984 >         { ac_try='test -z "$ac_c_werror_flag"
7985 >                         || test ! -s conftest.err'
7986 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7987 >  (eval $ac_try) 2>&5
7988 >  ac_status=$?
7989 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7990 >  (exit $ac_status); }; } &&
7991 >         { ac_try='test -s conftest.$ac_objext'
7992 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7993 >  (eval $ac_try) 2>&5
7994 >  ac_status=$?
7995 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7996 >  (exit $ac_status); }; }; then
7997 >  ac_cv_c_const=yes
7998 > else
7999 >  echo "$as_me: failed program was:" >&5
8000 > sed 's/^/| /' conftest.$ac_ext >&5
8001 >
8002 > ac_cv_c_const=no
8003 > fi
8004 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8005 > fi
8006 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8007 > echo "${ECHO_T}$ac_cv_c_const" >&6
8008 > if test $ac_cv_c_const = no; then
8009 >
8010 > cat >>confdefs.h <<\_ACEOF
8011 > #define const
8012 > _ACEOF
8013 >
8014 > fi
8015 >
8016 > echo "$as_me:$LINENO: checking for inline" >&5
8017 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8018 > if test "${ac_cv_c_inline+set}" = set; then
8019 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8020 > else
8021 >  ac_cv_c_inline=no
8022 > for ac_kw in inline __inline__ __inline; do
8023 >  cat >conftest.$ac_ext <<_ACEOF
8024 > /* confdefs.h.  */
8025 > _ACEOF
8026 > cat confdefs.h >>conftest.$ac_ext
8027 > cat >>conftest.$ac_ext <<_ACEOF
8028 > /* end confdefs.h.  */
8029 > #ifndef __cplusplus
8030 > typedef int foo_t;
8031 > static $ac_kw foo_t static_foo () {return 0; }
8032 > $ac_kw foo_t foo () {return 0; }
8033 > #endif
8034 >
8035 > _ACEOF
8036 > rm -f conftest.$ac_objext
8037 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8038 >  (eval $ac_compile) 2>conftest.er1
8039 >  ac_status=$?
8040 >  grep -v '^ *+' conftest.er1 >conftest.err
8041 >  rm -f conftest.er1
8042 >  cat conftest.err >&5
8043 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8044 >  (exit $ac_status); } &&
8045 >         { ac_try='test -z "$ac_c_werror_flag"
8046 >                         || test ! -s conftest.err'
8047 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8048 >  (eval $ac_try) 2>&5
8049 >  ac_status=$?
8050 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8051 >  (exit $ac_status); }; } &&
8052 >         { ac_try='test -s conftest.$ac_objext'
8053 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8054 >  (eval $ac_try) 2>&5
8055 >  ac_status=$?
8056 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8057 >  (exit $ac_status); }; }; then
8058 >  ac_cv_c_inline=$ac_kw; break
8059 > else
8060 >  echo "$as_me: failed program was:" >&5
8061 > sed 's/^/| /' conftest.$ac_ext >&5
8062 >
8063 > fi
8064 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8065 > done
8066 >
8067 > fi
8068 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8069 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8070 >
8071 >
8072 > case $ac_cv_c_inline in
8073 >  inline | yes) ;;
8074 >  *)
8075 >    case $ac_cv_c_inline in
8076 >      no) ac_val=;;
8077 >      *) ac_val=$ac_cv_c_inline;;
8078 >    esac
8079 >    cat >>confdefs.h <<_ACEOF
8080 > #ifndef __cplusplus
8081 > #define inline $ac_val
8082 > #endif
8083 > _ACEOF
8084 >    ;;
8085 > esac
8086 >
8087 >
8088 > # Checks for library functions.
8089 >
8090 > for ac_header in stdlib.h
8091 > do
8092 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8093 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8094 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8095 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8096 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8097 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8098 > fi
8099 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8100 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8101 > else
8102 >  # Is the header compilable?
8103 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8104 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8105 > cat >conftest.$ac_ext <<_ACEOF
8106 > /* confdefs.h.  */
8107 > _ACEOF
8108 > cat confdefs.h >>conftest.$ac_ext
8109 > cat >>conftest.$ac_ext <<_ACEOF
8110 > /* end confdefs.h.  */
8111 > $ac_includes_default
8112 > #include <$ac_header>
8113 > _ACEOF
8114 > rm -f conftest.$ac_objext
8115 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8116 >  (eval $ac_compile) 2>conftest.er1
8117 >  ac_status=$?
8118 >  grep -v '^ *+' conftest.er1 >conftest.err
8119 >  rm -f conftest.er1
8120 >  cat conftest.err >&5
8121 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8122 >  (exit $ac_status); } &&
8123 >         { ac_try='test -z "$ac_c_werror_flag"
8124 >                         || test ! -s conftest.err'
8125 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8126 >  (eval $ac_try) 2>&5
8127 >  ac_status=$?
8128 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8129 >  (exit $ac_status); }; } &&
8130 >         { ac_try='test -s conftest.$ac_objext'
8131 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8132 >  (eval $ac_try) 2>&5
8133 >  ac_status=$?
8134 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8135 >  (exit $ac_status); }; }; then
8136 >  ac_header_compiler=yes
8137 > else
8138 >  echo "$as_me: failed program was:" >&5
8139 > sed 's/^/| /' conftest.$ac_ext >&5
8140 >
8141 > ac_header_compiler=no
8142 > fi
8143 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8144 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8145 > echo "${ECHO_T}$ac_header_compiler" >&6
8146 >
8147 > # Is the header present?
8148 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8149 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8150 > cat >conftest.$ac_ext <<_ACEOF
8151 > /* confdefs.h.  */
8152 > _ACEOF
8153 > cat confdefs.h >>conftest.$ac_ext
8154 > cat >>conftest.$ac_ext <<_ACEOF
8155 > /* end confdefs.h.  */
8156 > #include <$ac_header>
8157 > _ACEOF
8158 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8159 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8160 >  ac_status=$?
8161 >  grep -v '^ *+' conftest.er1 >conftest.err
8162 >  rm -f conftest.er1
8163 >  cat conftest.err >&5
8164 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8165 >  (exit $ac_status); } >/dev/null; then
8166 >  if test -s conftest.err; then
8167 >    ac_cpp_err=$ac_c_preproc_warn_flag
8168 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8169 >  else
8170 >    ac_cpp_err=
8171 >  fi
8172 > else
8173 >  ac_cpp_err=yes
8174 > fi
8175 > if test -z "$ac_cpp_err"; then
8176 >  ac_header_preproc=yes
8177 > else
8178 >  echo "$as_me: failed program was:" >&5
8179 > sed 's/^/| /' conftest.$ac_ext >&5
8180 >
8181 >  ac_header_preproc=no
8182 > fi
8183 > rm -f conftest.err conftest.$ac_ext
8184 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8185 > echo "${ECHO_T}$ac_header_preproc" >&6
8186 >
8187 > # So?  What about this header?
8188 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8189 >  yes:no: )
8190 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8191 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8192 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8193 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8194 >    ac_header_preproc=yes
8195 >    ;;
8196 >  no:yes:* )
8197 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8198 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8199 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8200 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8201 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8202 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8203 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8204 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8205 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8206 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8207 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8208 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8209 >    (
8210 >      cat <<\_ASBOX
8211 > ## ------------------------------ ##
8212 > ## Report this to gezelter@nd.edu ##
8213 > ## ------------------------------ ##
8214 > _ASBOX
8215 >    ) |
8216 >      sed "s/^/$as_me: WARNING:     /" >&2
8217 >    ;;
8218 > esac
8219 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8220 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8221 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8222 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8223 > else
8224 >  eval "$as_ac_Header=\$ac_header_preproc"
8225 > fi
8226 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8227 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8228 >
8229 > fi
8230 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8231 >  cat >>confdefs.h <<_ACEOF
8232 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8233 > _ACEOF
8234 >
8235 > fi
8236 >
8237 > done
8238 >
8239 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8240 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8241 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8242 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8243 > else
8244 >  if test "$cross_compiling" = yes; then
8245 >  ac_cv_func_malloc_0_nonnull=no
8246 > else
8247 >  cat >conftest.$ac_ext <<_ACEOF
8248 > /* confdefs.h.  */
8249 > _ACEOF
8250 > cat confdefs.h >>conftest.$ac_ext
8251 > cat >>conftest.$ac_ext <<_ACEOF
8252 > /* end confdefs.h.  */
8253 > #if STDC_HEADERS || HAVE_STDLIB_H
8254 > # include <stdlib.h>
8255 > #else
8256 > char *malloc ();
8257 > #endif
8258 >
8259 > #ifdef FC_DUMMY_MAIN
8260 > #ifndef FC_DUMMY_MAIN_EQ_F77
8261 > #  ifdef __cplusplus
8262 >     extern "C"
8263 > #  endif
8264 >   int FC_DUMMY_MAIN() { return 1; }
8265 > #endif
8266 > #endif
8267 > int
8268 > main ()
8269 > {
8270 > exit (malloc (0) ? 0 : 1);
8271 >  ;
8272 >  return 0;
8273 > }
8274 > _ACEOF
8275 > rm -f conftest$ac_exeext
8276 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8277 >  (eval $ac_link) 2>&5
8278 >  ac_status=$?
8279 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8280 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8281 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8282 >  (eval $ac_try) 2>&5
8283 >  ac_status=$?
8284 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8285 >  (exit $ac_status); }; }; then
8286 >  ac_cv_func_malloc_0_nonnull=yes
8287 > else
8288 >  echo "$as_me: program exited with status $ac_status" >&5
8289 > echo "$as_me: failed program was:" >&5
8290 > sed 's/^/| /' conftest.$ac_ext >&5
8291 >
8292 > ( exit $ac_status )
8293 > ac_cv_func_malloc_0_nonnull=no
8294 > fi
8295 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8296 > fi
8297 > fi
8298 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8299 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8300 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8301 >
8302 > cat >>confdefs.h <<\_ACEOF
8303 > #define HAVE_MALLOC 1
8304 > _ACEOF
8305 >
8306 > else
8307 >  cat >>confdefs.h <<\_ACEOF
8308 > #define HAVE_MALLOC 0
8309 > _ACEOF
8310 >
8311 >   case $LIBOBJS in
8312 >    "malloc.$ac_objext"   | \
8313 >  *" malloc.$ac_objext"   | \
8314 >    "malloc.$ac_objext "* | \
8315 >  *" malloc.$ac_objext "* ) ;;
8316 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8317 > esac
8318 >
8319 >
8320 > cat >>confdefs.h <<\_ACEOF
8321 > #define malloc rpl_malloc
8322 > _ACEOF
8323 >
8324 > fi
8325 >
8326 >
8327 >
8328 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8329 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8330 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8331 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8332 > else
8333 >  if test "$cross_compiling" = yes; then
8334 >  ac_cv_func_memcmp_working=no
8335 > else
8336 >  cat >conftest.$ac_ext <<_ACEOF
8337 > /* confdefs.h.  */
8338 > _ACEOF
8339 > cat confdefs.h >>conftest.$ac_ext
8340 > cat >>conftest.$ac_ext <<_ACEOF
8341 > /* end confdefs.h.  */
8342 > $ac_includes_default
8343 > #ifdef FC_DUMMY_MAIN
8344 > #ifndef FC_DUMMY_MAIN_EQ_F77
8345 > #  ifdef __cplusplus
8346 >     extern "C"
8347 > #  endif
8348 >   int FC_DUMMY_MAIN() { return 1; }
8349 > #endif
8350 > #endif
8351 > int
8352 > main ()
8353 > {
8354 >
8355 >  /* Some versions of memcmp are not 8-bit clean.  */
8356 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8357 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8358 >    exit (1);
8359 >
8360 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8361 >     or more and with at least one buffer not starting on a 4-byte boundary.
8362 >     William Lewis provided this test program.   */
8363 >  {
8364 >    char foo[21];
8365 >    char bar[21];
8366 >    int i;
8367 >    for (i = 0; i < 4; i++)
8368 >      {
8369 >        char *a = foo + i;
8370 >        char *b = bar + i;
8371 >        strcpy (a, "--------01111111");
8372 >        strcpy (b, "--------10000000");
8373 >        if (memcmp (a, b, 16) >= 0)
8374 >          exit (1);
8375 >      }
8376 >    exit (0);
8377 >  }
8378 >
8379 >  ;
8380 >  return 0;
8381 > }
8382 > _ACEOF
8383 > rm -f conftest$ac_exeext
8384 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8385 >  (eval $ac_link) 2>&5
8386 >  ac_status=$?
8387 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8388 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8389 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8390 >  (eval $ac_try) 2>&5
8391 >  ac_status=$?
8392 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8393 >  (exit $ac_status); }; }; then
8394 >  ac_cv_func_memcmp_working=yes
8395 > else
8396 >  echo "$as_me: program exited with status $ac_status" >&5
8397 > echo "$as_me: failed program was:" >&5
8398 > sed 's/^/| /' conftest.$ac_ext >&5
8399 >
8400 > ( exit $ac_status )
8401 > ac_cv_func_memcmp_working=no
8402 > fi
8403 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8404 > fi
8405 > fi
8406 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8407 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8408 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8409 >    "memcmp.$ac_objext"   | \
8410 >  *" memcmp.$ac_objext"   | \
8411 >    "memcmp.$ac_objext "* | \
8412 >  *" memcmp.$ac_objext "* ) ;;
8413 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8414 > esac
8415 >
8416 >
8417 >
8418 > for ac_header in stdlib.h
8419 > do
8420 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8421 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8422 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8423 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8424 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8425 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8426 > fi
8427 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8428 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8429 > else
8430 >  # Is the header compilable?
8431 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8432 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8433 > cat >conftest.$ac_ext <<_ACEOF
8434 > /* confdefs.h.  */
8435 > _ACEOF
8436 > cat confdefs.h >>conftest.$ac_ext
8437 > cat >>conftest.$ac_ext <<_ACEOF
8438 > /* end confdefs.h.  */
8439 > $ac_includes_default
8440 > #include <$ac_header>
8441 > _ACEOF
8442 > rm -f conftest.$ac_objext
8443 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8444 >  (eval $ac_compile) 2>conftest.er1
8445 >  ac_status=$?
8446 >  grep -v '^ *+' conftest.er1 >conftest.err
8447 >  rm -f conftest.er1
8448 >  cat conftest.err >&5
8449 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8450 >  (exit $ac_status); } &&
8451 >         { ac_try='test -z "$ac_c_werror_flag"
8452 >                         || test ! -s conftest.err'
8453 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8454 >  (eval $ac_try) 2>&5
8455 >  ac_status=$?
8456 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8457 >  (exit $ac_status); }; } &&
8458 >         { ac_try='test -s conftest.$ac_objext'
8459 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8460 >  (eval $ac_try) 2>&5
8461 >  ac_status=$?
8462 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8463 >  (exit $ac_status); }; }; then
8464 >  ac_header_compiler=yes
8465 > else
8466 >  echo "$as_me: failed program was:" >&5
8467 > sed 's/^/| /' conftest.$ac_ext >&5
8468 >
8469 > ac_header_compiler=no
8470 > fi
8471 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8472 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8473 > echo "${ECHO_T}$ac_header_compiler" >&6
8474 >
8475 > # Is the header present?
8476 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8477 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8478 > cat >conftest.$ac_ext <<_ACEOF
8479 > /* confdefs.h.  */
8480 > _ACEOF
8481 > cat confdefs.h >>conftest.$ac_ext
8482 > cat >>conftest.$ac_ext <<_ACEOF
8483 > /* end confdefs.h.  */
8484 > #include <$ac_header>
8485 > _ACEOF
8486 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8487 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8488 >  ac_status=$?
8489 >  grep -v '^ *+' conftest.er1 >conftest.err
8490 >  rm -f conftest.er1
8491 >  cat conftest.err >&5
8492 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8493 >  (exit $ac_status); } >/dev/null; then
8494 >  if test -s conftest.err; then
8495 >    ac_cpp_err=$ac_c_preproc_warn_flag
8496 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8497 >  else
8498 >    ac_cpp_err=
8499 >  fi
8500 > else
8501 >  ac_cpp_err=yes
8502 > fi
8503 > if test -z "$ac_cpp_err"; then
8504 >  ac_header_preproc=yes
8505 > else
8506 >  echo "$as_me: failed program was:" >&5
8507 > sed 's/^/| /' conftest.$ac_ext >&5
8508 >
8509 >  ac_header_preproc=no
8510 > fi
8511 > rm -f conftest.err conftest.$ac_ext
8512 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8513 > echo "${ECHO_T}$ac_header_preproc" >&6
8514 >
8515 > # So?  What about this header?
8516 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8517 >  yes:no: )
8518 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8519 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8520 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8521 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8522 >    ac_header_preproc=yes
8523 >    ;;
8524 >  no:yes:* )
8525 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8526 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8527 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8528 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8529 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8530 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8531 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8532 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8533 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8534 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8535 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8536 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8537 >    (
8538 >      cat <<\_ASBOX
8539 > ## ------------------------------ ##
8540 > ## Report this to gezelter@nd.edu ##
8541 > ## ------------------------------ ##
8542 > _ASBOX
8543 >    ) |
8544 >      sed "s/^/$as_me: WARNING:     /" >&2
8545 >    ;;
8546 > esac
8547 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8548 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8549 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8550 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8551 > else
8552 >  eval "$as_ac_Header=\$ac_header_preproc"
8553 > fi
8554 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8555 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8556 >
8557 > fi
8558 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8559 >  cat >>confdefs.h <<_ACEOF
8560 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8561 > _ACEOF
8562 >
8563 > fi
8564 >
8565 > done
8566 >
8567 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8568 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8569 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8570 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8571 > else
8572 >  if test "$cross_compiling" = yes; then
8573 >  ac_cv_func_realloc_0_nonnull=no
8574 > else
8575 >  cat >conftest.$ac_ext <<_ACEOF
8576 > /* confdefs.h.  */
8577 > _ACEOF
8578 > cat confdefs.h >>conftest.$ac_ext
8579 > cat >>conftest.$ac_ext <<_ACEOF
8580 > /* end confdefs.h.  */
8581 > #if STDC_HEADERS || HAVE_STDLIB_H
8582 > # include <stdlib.h>
8583 > #else
8584 > char *realloc ();
8585 > #endif
8586 >
8587 > #ifdef FC_DUMMY_MAIN
8588 > #ifndef FC_DUMMY_MAIN_EQ_F77
8589 > #  ifdef __cplusplus
8590 >     extern "C"
8591 > #  endif
8592 >   int FC_DUMMY_MAIN() { return 1; }
8593 > #endif
8594 > #endif
8595 > int
8596 > main ()
8597 > {
8598 > exit (realloc (0, 0) ? 0 : 1);
8599 >  ;
8600 >  return 0;
8601 > }
8602 > _ACEOF
8603 > rm -f conftest$ac_exeext
8604 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8605 >  (eval $ac_link) 2>&5
8606 >  ac_status=$?
8607 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8608 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8609 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8610 >  (eval $ac_try) 2>&5
8611 >  ac_status=$?
8612 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8613 >  (exit $ac_status); }; }; then
8614 >  ac_cv_func_realloc_0_nonnull=yes
8615 > else
8616 >  echo "$as_me: program exited with status $ac_status" >&5
8617 > echo "$as_me: failed program was:" >&5
8618 > sed 's/^/| /' conftest.$ac_ext >&5
8619 >
8620 > ( exit $ac_status )
8621 > ac_cv_func_realloc_0_nonnull=no
8622 > fi
8623 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8624 > fi
8625 > fi
8626 > echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8627 > echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8628 > if test $ac_cv_func_realloc_0_nonnull = yes; then
8629 >
8630 > cat >>confdefs.h <<\_ACEOF
8631 > #define HAVE_REALLOC 1
8632 > _ACEOF
8633 >
8634 > else
8635 >  cat >>confdefs.h <<\_ACEOF
8636 > #define HAVE_REALLOC 0
8637 > _ACEOF
8638 >
8639 >   case $LIBOBJS in
8640 >    "realloc.$ac_objext"   | \
8641 >  *" realloc.$ac_objext"   | \
8642 >    "realloc.$ac_objext "* | \
8643 >  *" realloc.$ac_objext "* ) ;;
8644 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8645 > esac
8646 >
8647 >
8648 > cat >>confdefs.h <<\_ACEOF
8649 > #define realloc rpl_realloc
8650 > _ACEOF
8651 >
8652 > fi
8653 >
8654 >
8655 >
8656 >
8657 >
8658 > for ac_header in sys/select.h sys/socket.h
8659 > do
8660 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8661 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8662 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8663 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8664 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8665 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8666 > fi
8667 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8668 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8669 > else
8670 >  # Is the header compilable?
8671 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8672 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8673 > cat >conftest.$ac_ext <<_ACEOF
8674 > /* confdefs.h.  */
8675 > _ACEOF
8676 > cat confdefs.h >>conftest.$ac_ext
8677 > cat >>conftest.$ac_ext <<_ACEOF
8678 > /* end confdefs.h.  */
8679 > $ac_includes_default
8680 > #include <$ac_header>
8681 > _ACEOF
8682 > rm -f conftest.$ac_objext
8683 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8684 >  (eval $ac_compile) 2>conftest.er1
8685 >  ac_status=$?
8686 >  grep -v '^ *+' conftest.er1 >conftest.err
8687 >  rm -f conftest.er1
8688 >  cat conftest.err >&5
8689 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8690 >  (exit $ac_status); } &&
8691 >         { ac_try='test -z "$ac_c_werror_flag"
8692 >                         || test ! -s conftest.err'
8693 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8694 >  (eval $ac_try) 2>&5
8695 >  ac_status=$?
8696 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8697 >  (exit $ac_status); }; } &&
8698 >         { ac_try='test -s conftest.$ac_objext'
8699 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8700 >  (eval $ac_try) 2>&5
8701 >  ac_status=$?
8702 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8703 >  (exit $ac_status); }; }; then
8704 >  ac_header_compiler=yes
8705 > else
8706 >  echo "$as_me: failed program was:" >&5
8707 > sed 's/^/| /' conftest.$ac_ext >&5
8708 >
8709 > ac_header_compiler=no
8710 > fi
8711 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8712 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8713 > echo "${ECHO_T}$ac_header_compiler" >&6
8714 >
8715 > # Is the header present?
8716 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8717 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8718 > cat >conftest.$ac_ext <<_ACEOF
8719 > /* confdefs.h.  */
8720 > _ACEOF
8721 > cat confdefs.h >>conftest.$ac_ext
8722 > cat >>conftest.$ac_ext <<_ACEOF
8723 > /* end confdefs.h.  */
8724 > #include <$ac_header>
8725 > _ACEOF
8726 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8727 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8728 >  ac_status=$?
8729 >  grep -v '^ *+' conftest.er1 >conftest.err
8730 >  rm -f conftest.er1
8731 >  cat conftest.err >&5
8732 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8733 >  (exit $ac_status); } >/dev/null; then
8734 >  if test -s conftest.err; then
8735 >    ac_cpp_err=$ac_c_preproc_warn_flag
8736 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8737 >  else
8738 >    ac_cpp_err=
8739 >  fi
8740 > else
8741 >  ac_cpp_err=yes
8742 > fi
8743 > if test -z "$ac_cpp_err"; then
8744 >  ac_header_preproc=yes
8745 > else
8746 >  echo "$as_me: failed program was:" >&5
8747 > sed 's/^/| /' conftest.$ac_ext >&5
8748 >
8749 >  ac_header_preproc=no
8750 > fi
8751 > rm -f conftest.err conftest.$ac_ext
8752 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8753 > echo "${ECHO_T}$ac_header_preproc" >&6
8754 >
8755 > # So?  What about this header?
8756 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8757 >  yes:no: )
8758 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8759 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8760 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8761 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8762 >    ac_header_preproc=yes
8763 >    ;;
8764 >  no:yes:* )
8765 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8766 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8767 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8768 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8769 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8770 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8771 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8772 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8773 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8774 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8775 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8776 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8777 >    (
8778 >      cat <<\_ASBOX
8779 > ## ------------------------------ ##
8780 > ## Report this to gezelter@nd.edu ##
8781 > ## ------------------------------ ##
8782 > _ASBOX
8783 >    ) |
8784 >      sed "s/^/$as_me: WARNING:     /" >&2
8785 >    ;;
8786 > esac
8787 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8788 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8789 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8790 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8791 > else
8792 >  eval "$as_ac_Header=\$ac_header_preproc"
8793 > fi
8794 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8795 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8796 >
8797 > fi
8798 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8799 >  cat >>confdefs.h <<_ACEOF
8800 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8801 > _ACEOF
8802 >
8803 > fi
8804 >
8805 > done
8806 >
8807 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
8808 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8809 > if test "${ac_cv_func_select_args+set}" = set; then
8810 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8811 > else
8812 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8813 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8814 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8815 >   cat >conftest.$ac_ext <<_ACEOF
8816 > /* confdefs.h.  */
8817 > _ACEOF
8818 > cat confdefs.h >>conftest.$ac_ext
8819 > cat >>conftest.$ac_ext <<_ACEOF
8820 > /* end confdefs.h.  */
8821 > $ac_includes_default
8822 > #if HAVE_SYS_SELECT_H
8823 > # include <sys/select.h>
8824 > #endif
8825 > #if HAVE_SYS_SOCKET_H
8826 > # include <sys/socket.h>
8827 > #endif
8828 >
8829 > #ifdef FC_DUMMY_MAIN
8830 > #ifndef FC_DUMMY_MAIN_EQ_F77
8831 > #  ifdef __cplusplus
8832 >     extern "C"
8833 > #  endif
8834 >   int FC_DUMMY_MAIN() { return 1; }
8835 > #endif
8836 > #endif
8837 > int
8838 > main ()
8839 > {
8840 > extern int select ($ac_arg1,
8841 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
8842 >                                            $ac_arg5);
8843 >  ;
8844 >  return 0;
8845 > }
8846 > _ACEOF
8847 > rm -f conftest.$ac_objext
8848 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8849 >  (eval $ac_compile) 2>conftest.er1
8850 >  ac_status=$?
8851 >  grep -v '^ *+' conftest.er1 >conftest.err
8852 >  rm -f conftest.er1
8853 >  cat conftest.err >&5
8854 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8855 >  (exit $ac_status); } &&
8856 >         { ac_try='test -z "$ac_c_werror_flag"
8857 >                         || test ! -s conftest.err'
8858 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8859 >  (eval $ac_try) 2>&5
8860 >  ac_status=$?
8861 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8862 >  (exit $ac_status); }; } &&
8863 >         { ac_try='test -s conftest.$ac_objext'
8864 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8865 >  (eval $ac_try) 2>&5
8866 >  ac_status=$?
8867 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8868 >  (exit $ac_status); }; }; then
8869 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8870 > else
8871 >  echo "$as_me: failed program was:" >&5
8872 > sed 's/^/| /' conftest.$ac_ext >&5
8873 >
8874 > fi
8875 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8876 >  done
8877 > done
8878 > done
8879 > # Provide a safe default value.
8880 > : ${ac_cv_func_select_args='int,int *,struct timeval *'}
8881 >
8882 > fi
8883 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8884 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
8885 > ac_save_IFS=$IFS; IFS=','
8886 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8887 > IFS=$ac_save_IFS
8888 > shift
8889 >
8890 > cat >>confdefs.h <<_ACEOF
8891 > #define SELECT_TYPE_ARG1 $1
8892 > _ACEOF
8893 >
8894 >
8895 > cat >>confdefs.h <<_ACEOF
8896 > #define SELECT_TYPE_ARG234 ($2)
8897 > _ACEOF
8898 >
8899 >
8900 > cat >>confdefs.h <<_ACEOF
8901 > #define SELECT_TYPE_ARG5 ($3)
8902 > _ACEOF
8903 >
8904 > rm -f conftest*
8905 >
8906 >
8907 > for ac_func in strftime
8908 > do
8909 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8910 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8911 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8912 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8913 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8914 > else
8915 >  cat >conftest.$ac_ext <<_ACEOF
8916 > /* confdefs.h.  */
8917 > _ACEOF
8918 > cat confdefs.h >>conftest.$ac_ext
8919 > cat >>conftest.$ac_ext <<_ACEOF
8920 > /* end confdefs.h.  */
8921 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8922 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8923 > #define $ac_func innocuous_$ac_func
8924 >
8925 > /* System header to define __stub macros and hopefully few prototypes,
8926 >    which can conflict with char $ac_func (); below.
8927 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8928 >    <limits.h> exists even on freestanding compilers.  */
8929 >
8930 > #ifdef __STDC__
8931 > # include <limits.h>
8932 > #else
8933 > # include <assert.h>
8934 > #endif
8935 >
8936 > #undef $ac_func
8937 >
8938 > /* Override any gcc2 internal prototype to avoid an error.  */
8939 > #ifdef __cplusplus
8940 > extern "C"
8941 > {
8942 > #endif
8943 > /* We use char because int might match the return type of a gcc2
8944 >   builtin and then its argument prototype would still apply.  */
8945 > char $ac_func ();
8946 > /* The GNU C library defines this for functions which it implements
8947 >    to always fail with ENOSYS.  Some functions are actually named
8948 >    something starting with __ and the normal name is an alias.  */
8949 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8950 > choke me
8951 > #else
8952 > char (*f) () = $ac_func;
8953 > #endif
8954 > #ifdef __cplusplus
8955 > }
8956 > #endif
8957 >
8958 > #ifdef FC_DUMMY_MAIN
8959 > #ifndef FC_DUMMY_MAIN_EQ_F77
8960 > #  ifdef __cplusplus
8961 >     extern "C"
8962 > #  endif
8963 >   int FC_DUMMY_MAIN() { return 1; }
8964 > #endif
8965 > #endif
8966 > int
8967 > main ()
8968 > {
8969 > return f != $ac_func;
8970 >  ;
8971 >  return 0;
8972 > }
8973 > _ACEOF
8974 > rm -f conftest.$ac_objext conftest$ac_exeext
8975 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8976 >  (eval $ac_link) 2>conftest.er1
8977 >  ac_status=$?
8978 >  grep -v '^ *+' conftest.er1 >conftest.err
8979 >  rm -f conftest.er1
8980 >  cat conftest.err >&5
8981 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8982 >  (exit $ac_status); } &&
8983 >         { ac_try='test -z "$ac_c_werror_flag"
8984 >                         || test ! -s conftest.err'
8985 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8986 >  (eval $ac_try) 2>&5
8987 >  ac_status=$?
8988 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8989 >  (exit $ac_status); }; } &&
8990 >         { ac_try='test -s conftest$ac_exeext'
8991 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8992 >  (eval $ac_try) 2>&5
8993 >  ac_status=$?
8994 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8995 >  (exit $ac_status); }; }; then
8996 >  eval "$as_ac_var=yes"
8997 > else
8998 >  echo "$as_me: failed program was:" >&5
8999 > sed 's/^/| /' conftest.$ac_ext >&5
9000 >
9001 > eval "$as_ac_var=no"
9002 > fi
9003 > rm -f conftest.err conftest.$ac_objext \
9004 >      conftest$ac_exeext conftest.$ac_ext
9005 > fi
9006 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9007 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9008 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9009 >  cat >>confdefs.h <<_ACEOF
9010 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9011 > _ACEOF
9012 >
9013 > else
9014 >  # strftime is in -lintl on SCO UNIX.
9015 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9016 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9017 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9018 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9019 > else
9020 >  ac_check_lib_save_LIBS=$LIBS
9021 > LIBS="-lintl  $LIBS"
9022 > cat >conftest.$ac_ext <<_ACEOF
9023 > /* confdefs.h.  */
9024 > _ACEOF
9025 > cat confdefs.h >>conftest.$ac_ext
9026 > cat >>conftest.$ac_ext <<_ACEOF
9027 > /* end confdefs.h.  */
9028 >
9029 > /* Override any gcc2 internal prototype to avoid an error.  */
9030 > #ifdef __cplusplus
9031 > extern "C"
9032 > #endif
9033 > /* We use char because int might match the return type of a gcc2
9034 >   builtin and then its argument prototype would still apply.  */
9035 > char strftime ();
9036 > #ifdef FC_DUMMY_MAIN
9037 > #ifndef FC_DUMMY_MAIN_EQ_F77
9038 > #  ifdef __cplusplus
9039 >     extern "C"
9040 > #  endif
9041 >   int FC_DUMMY_MAIN() { return 1; }
9042 > #endif
9043 > #endif
9044 > int
9045 > main ()
9046 > {
9047 > strftime ();
9048 >  ;
9049 >  return 0;
9050 > }
9051 > _ACEOF
9052 > rm -f conftest.$ac_objext conftest$ac_exeext
9053 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9054 >  (eval $ac_link) 2>conftest.er1
9055 >  ac_status=$?
9056 >  grep -v '^ *+' conftest.er1 >conftest.err
9057 >  rm -f conftest.er1
9058 >  cat conftest.err >&5
9059 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9060 >  (exit $ac_status); } &&
9061 >         { ac_try='test -z "$ac_c_werror_flag"
9062 >                         || test ! -s conftest.err'
9063 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9064 >  (eval $ac_try) 2>&5
9065 >  ac_status=$?
9066 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9067 >  (exit $ac_status); }; } &&
9068 >         { ac_try='test -s conftest$ac_exeext'
9069 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9070 >  (eval $ac_try) 2>&5
9071 >  ac_status=$?
9072 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9073 >  (exit $ac_status); }; }; then
9074 >  ac_cv_lib_intl_strftime=yes
9075 > else
9076 >  echo "$as_me: failed program was:" >&5
9077 > sed 's/^/| /' conftest.$ac_ext >&5
9078 >
9079 > ac_cv_lib_intl_strftime=no
9080 > fi
9081 > rm -f conftest.err conftest.$ac_objext \
9082 >      conftest$ac_exeext conftest.$ac_ext
9083 > LIBS=$ac_check_lib_save_LIBS
9084 > fi
9085 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9086 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9087 > if test $ac_cv_lib_intl_strftime = yes; then
9088 >  cat >>confdefs.h <<\_ACEOF
9089 > #define HAVE_STRFTIME 1
9090 > _ACEOF
9091 >
9092 > LIBS="-lintl $LIBS"
9093 > fi
9094 >
9095 > fi
9096 > done
9097 >
9098 > echo "$as_me:$LINENO: checking for working strtod" >&5
9099 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9100 > if test "${ac_cv_func_strtod+set}" = set; then
9101 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9102 > else
9103 >  if test "$cross_compiling" = yes; then
9104 >  ac_cv_func_strtod=no
9105 > else
9106 >  cat >conftest.$ac_ext <<_ACEOF
9107 > /* confdefs.h.  */
9108 > _ACEOF
9109 > cat confdefs.h >>conftest.$ac_ext
9110 > cat >>conftest.$ac_ext <<_ACEOF
9111 > /* end confdefs.h.  */
9112 >
9113 > double strtod ();
9114 > int
9115 > main()
9116 > {
9117 >  {
9118 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9119 >    char *string = " +69";
9120 >    char *term;
9121 >    double value;
9122 >    value = strtod (string, &term);
9123 >    if (value != 69 || term != (string + 4))
9124 >      exit (1);
9125 >  }
9126 >
9127 >  {
9128 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9129 >       terminating character under some conditions.  */
9130 >    char *string = "NaN";
9131 >    char *term;
9132 >    strtod (string, &term);
9133 >    if (term != string && *(term - 1) == 0)
9134 >      exit (1);
9135 >  }
9136 >  exit (0);
9137 > }
9138 >
9139 > _ACEOF
9140 > rm -f conftest$ac_exeext
9141 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9142 >  (eval $ac_link) 2>&5
9143 >  ac_status=$?
9144 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9145 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9146 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9147 >  (eval $ac_try) 2>&5
9148 >  ac_status=$?
9149 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9150 >  (exit $ac_status); }; }; then
9151 >  ac_cv_func_strtod=yes
9152 > else
9153 >  echo "$as_me: program exited with status $ac_status" >&5
9154 > echo "$as_me: failed program was:" >&5
9155 > sed 's/^/| /' conftest.$ac_ext >&5
9156 >
9157 > ( exit $ac_status )
9158 > ac_cv_func_strtod=no
9159 > fi
9160 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9161 > fi
9162 > fi
9163 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9164 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9165 > if test $ac_cv_func_strtod = no; then
9166 >  case $LIBOBJS in
9167 >    "strtod.$ac_objext"   | \
9168 >  *" strtod.$ac_objext"   | \
9169 >    "strtod.$ac_objext "* | \
9170 >  *" strtod.$ac_objext "* ) ;;
9171 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9172 > esac
9173 >
9174 > echo "$as_me:$LINENO: checking for pow" >&5
9175 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9176 > if test "${ac_cv_func_pow+set}" = set; then
9177 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9178 > else
9179 >  cat >conftest.$ac_ext <<_ACEOF
9180 > /* confdefs.h.  */
9181 > _ACEOF
9182 > cat confdefs.h >>conftest.$ac_ext
9183 > cat >>conftest.$ac_ext <<_ACEOF
9184 > /* end confdefs.h.  */
9185 > /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9186 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9187 > #define pow innocuous_pow
9188 >
9189 > /* System header to define __stub macros and hopefully few prototypes,
9190 >    which can conflict with char pow (); below.
9191 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9192 >    <limits.h> exists even on freestanding compilers.  */
9193 >
9194 > #ifdef __STDC__
9195 > # include <limits.h>
9196 > #else
9197 > # include <assert.h>
9198 > #endif
9199 >
9200 > #undef pow
9201 >
9202 > /* Override any gcc2 internal prototype to avoid an error.  */
9203 > #ifdef __cplusplus
9204 > extern "C"
9205 > {
9206 > #endif
9207 > /* We use char because int might match the return type of a gcc2
9208 >   builtin and then its argument prototype would still apply.  */
9209 > char pow ();
9210 > /* The GNU C library defines this for functions which it implements
9211 >    to always fail with ENOSYS.  Some functions are actually named
9212 >    something starting with __ and the normal name is an alias.  */
9213 > #if defined (__stub_pow) || defined (__stub___pow)
9214 > choke me
9215 > #else
9216 > char (*f) () = pow;
9217 > #endif
9218 > #ifdef __cplusplus
9219 > }
9220 > #endif
9221 >
9222 > #ifdef FC_DUMMY_MAIN
9223 > #ifndef FC_DUMMY_MAIN_EQ_F77
9224 > #  ifdef __cplusplus
9225 >     extern "C"
9226 > #  endif
9227 >   int FC_DUMMY_MAIN() { return 1; }
9228 > #endif
9229 > #endif
9230 > int
9231 > main ()
9232 > {
9233 > return f != pow;
9234 >  ;
9235 >  return 0;
9236 > }
9237 > _ACEOF
9238 > rm -f conftest.$ac_objext conftest$ac_exeext
9239 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9240 >  (eval $ac_link) 2>conftest.er1
9241 >  ac_status=$?
9242 >  grep -v '^ *+' conftest.er1 >conftest.err
9243 >  rm -f conftest.er1
9244 >  cat conftest.err >&5
9245 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9246 >  (exit $ac_status); } &&
9247 >         { ac_try='test -z "$ac_c_werror_flag"
9248 >                         || test ! -s conftest.err'
9249 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9250 >  (eval $ac_try) 2>&5
9251 >  ac_status=$?
9252 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9253 >  (exit $ac_status); }; } &&
9254 >         { ac_try='test -s conftest$ac_exeext'
9255 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9256 >  (eval $ac_try) 2>&5
9257 >  ac_status=$?
9258 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9259 >  (exit $ac_status); }; }; then
9260 >  ac_cv_func_pow=yes
9261 > else
9262 >  echo "$as_me: failed program was:" >&5
9263 > sed 's/^/| /' conftest.$ac_ext >&5
9264 >
9265 > ac_cv_func_pow=no
9266 > fi
9267 > rm -f conftest.err conftest.$ac_objext \
9268 >      conftest$ac_exeext conftest.$ac_ext
9269 > fi
9270 > echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9271 > echo "${ECHO_T}$ac_cv_func_pow" >&6
9272 >
9273 > if test $ac_cv_func_pow = no; then
9274 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9275 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9276 > if test "${ac_cv_lib_m_pow+set}" = set; then
9277 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9278 > else
9279 >  ac_check_lib_save_LIBS=$LIBS
9280 > LIBS="-lm  $LIBS"
9281 > cat >conftest.$ac_ext <<_ACEOF
9282 > /* confdefs.h.  */
9283 > _ACEOF
9284 > cat confdefs.h >>conftest.$ac_ext
9285 > cat >>conftest.$ac_ext <<_ACEOF
9286 > /* end confdefs.h.  */
9287 >
9288 > /* Override any gcc2 internal prototype to avoid an error.  */
9289 > #ifdef __cplusplus
9290 > extern "C"
9291 > #endif
9292 > /* We use char because int might match the return type of a gcc2
9293 >   builtin and then its argument prototype would still apply.  */
9294 > char pow ();
9295 > #ifdef FC_DUMMY_MAIN
9296 > #ifndef FC_DUMMY_MAIN_EQ_F77
9297 > #  ifdef __cplusplus
9298 >     extern "C"
9299 > #  endif
9300 >   int FC_DUMMY_MAIN() { return 1; }
9301 > #endif
9302 > #endif
9303 > int
9304 > main ()
9305 > {
9306 > pow ();
9307 >  ;
9308 >  return 0;
9309 > }
9310 > _ACEOF
9311 > rm -f conftest.$ac_objext conftest$ac_exeext
9312 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9313 >  (eval $ac_link) 2>conftest.er1
9314 >  ac_status=$?
9315 >  grep -v '^ *+' conftest.er1 >conftest.err
9316 >  rm -f conftest.er1
9317 >  cat conftest.err >&5
9318 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9319 >  (exit $ac_status); } &&
9320 >         { ac_try='test -z "$ac_c_werror_flag"
9321 >                         || test ! -s conftest.err'
9322 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9323 >  (eval $ac_try) 2>&5
9324 >  ac_status=$?
9325 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9326 >  (exit $ac_status); }; } &&
9327 >         { ac_try='test -s conftest$ac_exeext'
9328 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9329 >  (eval $ac_try) 2>&5
9330 >  ac_status=$?
9331 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9332 >  (exit $ac_status); }; }; then
9333 >  ac_cv_lib_m_pow=yes
9334 > else
9335 >  echo "$as_me: failed program was:" >&5
9336 > sed 's/^/| /' conftest.$ac_ext >&5
9337 >
9338 > ac_cv_lib_m_pow=no
9339 > fi
9340 > rm -f conftest.err conftest.$ac_objext \
9341 >      conftest$ac_exeext conftest.$ac_ext
9342 > LIBS=$ac_check_lib_save_LIBS
9343 > fi
9344 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9345 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9346 > if test $ac_cv_lib_m_pow = yes; then
9347 >  POW_LIB=-lm
9348 > else
9349 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9350 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9351 > fi
9352 >
9353 > fi
9354 >
9355 > fi
9356 >
9357 >
9358 >
9359 >
9360 >
9361 >
9362 >
9363 >
9364 >
9365 >
9366 >
9367 >
9368 >
9369 >
9370 >
9371 >
9372 >
9373 >
9374 >
9375 >
9376 >
9377 >
9378 >
9379 >
9380 >
9381 >
9382 >
9383 >
9384 > 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
9385 > do
9386 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9387 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9388 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9389 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9390 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9391 > else
9392 >  cat >conftest.$ac_ext <<_ACEOF
9393 > /* confdefs.h.  */
9394 > _ACEOF
9395 > cat confdefs.h >>conftest.$ac_ext
9396 > cat >>conftest.$ac_ext <<_ACEOF
9397 > /* end confdefs.h.  */
9398 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9399 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9400 > #define $ac_func innocuous_$ac_func
9401 >
9402 > /* System header to define __stub macros and hopefully few prototypes,
9403 >    which can conflict with char $ac_func (); below.
9404 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9405 >    <limits.h> exists even on freestanding compilers.  */
9406 >
9407 > #ifdef __STDC__
9408 > # include <limits.h>
9409 > #else
9410 > # include <assert.h>
9411 > #endif
9412 >
9413 > #undef $ac_func
9414 >
9415 > /* Override any gcc2 internal prototype to avoid an error.  */
9416 > #ifdef __cplusplus
9417 > extern "C"
9418 > {
9419 > #endif
9420 > /* We use char because int might match the return type of a gcc2
9421 >   builtin and then its argument prototype would still apply.  */
9422 > char $ac_func ();
9423 > /* The GNU C library defines this for functions which it implements
9424 >    to always fail with ENOSYS.  Some functions are actually named
9425 >    something starting with __ and the normal name is an alias.  */
9426 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9427 > choke me
9428 > #else
9429 > char (*f) () = $ac_func;
9430 > #endif
9431 > #ifdef __cplusplus
9432 > }
9433 > #endif
9434 >
9435 > #ifdef FC_DUMMY_MAIN
9436 > #ifndef FC_DUMMY_MAIN_EQ_F77
9437 > #  ifdef __cplusplus
9438 >     extern "C"
9439 > #  endif
9440 >   int FC_DUMMY_MAIN() { return 1; }
9441 > #endif
9442 > #endif
9443 > int
9444 > main ()
9445 > {
9446 > return f != $ac_func;
9447 >  ;
9448 >  return 0;
9449 > }
9450 > _ACEOF
9451 > rm -f conftest.$ac_objext conftest$ac_exeext
9452 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9453 >  (eval $ac_link) 2>conftest.er1
9454 >  ac_status=$?
9455 >  grep -v '^ *+' conftest.er1 >conftest.err
9456 >  rm -f conftest.er1
9457 >  cat conftest.err >&5
9458 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9459 >  (exit $ac_status); } &&
9460 >         { ac_try='test -z "$ac_c_werror_flag"
9461 >                         || test ! -s conftest.err'
9462 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9463 >  (eval $ac_try) 2>&5
9464 >  ac_status=$?
9465 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9466 >  (exit $ac_status); }; } &&
9467 >         { ac_try='test -s conftest$ac_exeext'
9468 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9469 >  (eval $ac_try) 2>&5
9470 >  ac_status=$?
9471 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9472 >  (exit $ac_status); }; }; then
9473 >  eval "$as_ac_var=yes"
9474 > else
9475 >  echo "$as_me: failed program was:" >&5
9476 > sed 's/^/| /' conftest.$ac_ext >&5
9477 >
9478 > eval "$as_ac_var=no"
9479 > fi
9480 > rm -f conftest.err conftest.$ac_objext \
9481 >      conftest$ac_exeext conftest.$ac_ext
9482 > fi
9483 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9484 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9485 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9486 >  cat >>confdefs.h <<_ACEOF
9487 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9488 > _ACEOF
9489 >
9490 > fi
9491 > done
9492 >
9493 >
9494 > # special check for _system_configuration because AIX <4.3.2 do not
9495 > # contain the `physmem' member.
9496 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9497 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9498 > cat >conftest.$ac_ext <<_ACEOF
9499 > /* confdefs.h.  */
9500 > _ACEOF
9501 > cat confdefs.h >>conftest.$ac_ext
9502 > cat >>conftest.$ac_ext <<_ACEOF
9503 > /* end confdefs.h.  */
9504 > #include <sys/systemcfg.h>
9505 > #ifdef FC_DUMMY_MAIN
9506 > #ifndef FC_DUMMY_MAIN_EQ_F77
9507 > #  ifdef __cplusplus
9508 >     extern "C"
9509 > #  endif
9510 >   int FC_DUMMY_MAIN() { return 1; }
9511 > #endif
9512 > #endif
9513 > int
9514 > main ()
9515 > {
9516 > double x = _system_configuration.physmem;
9517 >  ;
9518 >  return 0;
9519 > }
9520 > _ACEOF
9521 > rm -f conftest.$ac_objext
9522 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9523 >  (eval $ac_compile) 2>conftest.er1
9524 >  ac_status=$?
9525 >  grep -v '^ *+' conftest.er1 >conftest.err
9526 >  rm -f conftest.er1
9527 >  cat conftest.err >&5
9528 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9529 >  (exit $ac_status); } &&
9530 >         { ac_try='test -z "$ac_c_werror_flag"
9531 >                         || test ! -s conftest.err'
9532 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9533 >  (eval $ac_try) 2>&5
9534 >  ac_status=$?
9535 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9536 >  (exit $ac_status); }; } &&
9537 >         { ac_try='test -s conftest.$ac_objext'
9538 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9539 >  (eval $ac_try) 2>&5
9540 >  ac_status=$?
9541 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9542 >  (exit $ac_status); }; }; then
9543 >  echo "$as_me:$LINENO: result: yes" >&5
9544 > echo "${ECHO_T}yes" >&6
9545 >
9546 > cat >>confdefs.h <<\_ACEOF
9547 > #define HAVE__SYSTEM_CONFIGURATION 1
9548 > _ACEOF
9549 >
9550 > else
9551 >  echo "$as_me: failed program was:" >&5
9552 > sed 's/^/| /' conftest.$ac_ext >&5
9553 >
9554 > echo "$as_me:$LINENO: result: no" >&5
9555 > echo "${ECHO_T}no" >&6
9556 > fi
9557 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9558 >
9559 >  # clean out junk possibly left behind by a previous configuration
9560 >  rm -f src/getopt.h
9561 >  # Check for getopt_long support
9562 >
9563 > for ac_header in getopt.h
9564 > do
9565 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9566 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9567 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9568 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9569 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9570 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9571 > fi
9572 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9573 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9574 > else
9575 >  # Is the header compilable?
9576 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9577 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9578 > cat >conftest.$ac_ext <<_ACEOF
9579 > /* confdefs.h.  */
9580 > _ACEOF
9581 > cat confdefs.h >>conftest.$ac_ext
9582 > cat >>conftest.$ac_ext <<_ACEOF
9583 > /* end confdefs.h.  */
9584 > $ac_includes_default
9585 > #include <$ac_header>
9586 > _ACEOF
9587 > rm -f conftest.$ac_objext
9588 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9589 >  (eval $ac_compile) 2>conftest.er1
9590 >  ac_status=$?
9591 >  grep -v '^ *+' conftest.er1 >conftest.err
9592 >  rm -f conftest.er1
9593 >  cat conftest.err >&5
9594 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9595 >  (exit $ac_status); } &&
9596 >         { ac_try='test -z "$ac_c_werror_flag"
9597 >                         || test ! -s conftest.err'
9598 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9599 >  (eval $ac_try) 2>&5
9600 >  ac_status=$?
9601 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9602 >  (exit $ac_status); }; } &&
9603 >         { ac_try='test -s conftest.$ac_objext'
9604 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9605 >  (eval $ac_try) 2>&5
9606 >  ac_status=$?
9607 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9608 >  (exit $ac_status); }; }; then
9609 >  ac_header_compiler=yes
9610 > else
9611 >  echo "$as_me: failed program was:" >&5
9612 > sed 's/^/| /' conftest.$ac_ext >&5
9613 >
9614 > ac_header_compiler=no
9615 > fi
9616 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9617 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9618 > echo "${ECHO_T}$ac_header_compiler" >&6
9619 >
9620 > # Is the header present?
9621 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9622 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9623 > cat >conftest.$ac_ext <<_ACEOF
9624 > /* confdefs.h.  */
9625 > _ACEOF
9626 > cat confdefs.h >>conftest.$ac_ext
9627 > cat >>conftest.$ac_ext <<_ACEOF
9628 > /* end confdefs.h.  */
9629 > #include <$ac_header>
9630 > _ACEOF
9631 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9632 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9633 >  ac_status=$?
9634 >  grep -v '^ *+' conftest.er1 >conftest.err
9635 >  rm -f conftest.er1
9636 >  cat conftest.err >&5
9637 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9638 >  (exit $ac_status); } >/dev/null; then
9639 >  if test -s conftest.err; then
9640 >    ac_cpp_err=$ac_c_preproc_warn_flag
9641 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9642 >  else
9643 >    ac_cpp_err=
9644 >  fi
9645 > else
9646 >  ac_cpp_err=yes
9647 > fi
9648 > if test -z "$ac_cpp_err"; then
9649 >  ac_header_preproc=yes
9650 > else
9651 >  echo "$as_me: failed program was:" >&5
9652 > sed 's/^/| /' conftest.$ac_ext >&5
9653 >
9654 >  ac_header_preproc=no
9655 > fi
9656 > rm -f conftest.err conftest.$ac_ext
9657 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9658 > echo "${ECHO_T}$ac_header_preproc" >&6
9659 >
9660 > # So?  What about this header?
9661 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9662 >  yes:no: )
9663 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9664 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9665 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9666 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9667 >    ac_header_preproc=yes
9668 >    ;;
9669 >  no:yes:* )
9670 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9671 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9672 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9673 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9674 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9675 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9676 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9677 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9678 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9679 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9680 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9681 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9682 >    (
9683 >      cat <<\_ASBOX
9684 > ## ------------------------------ ##
9685 > ## Report this to gezelter@nd.edu ##
9686 > ## ------------------------------ ##
9687 > _ASBOX
9688 >    ) |
9689 >      sed "s/^/$as_me: WARNING:     /" >&2
9690 >    ;;
9691 > esac
9692 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9693 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9694 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9695 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9696 > else
9697 >  eval "$as_ac_Header=\$ac_header_preproc"
9698 > fi
9699 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9700 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9701 >
9702 > fi
9703 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9704 >  cat >>confdefs.h <<_ACEOF
9705 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9706 > _ACEOF
9707 >
9708 > fi
9709 >
9710 > done
9711 >
9712 >
9713 > for ac_func in getopt_long
9714 > do
9715 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9716 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9717 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9718 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9719 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9720 > else
9721 >  cat >conftest.$ac_ext <<_ACEOF
9722 > /* confdefs.h.  */
9723 > _ACEOF
9724 > cat confdefs.h >>conftest.$ac_ext
9725 > cat >>conftest.$ac_ext <<_ACEOF
9726 > /* end confdefs.h.  */
9727 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9728 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9729 > #define $ac_func innocuous_$ac_func
9730 >
9731 > /* System header to define __stub macros and hopefully few prototypes,
9732 >    which can conflict with char $ac_func (); below.
9733 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9734 >    <limits.h> exists even on freestanding compilers.  */
9735 >
9736 > #ifdef __STDC__
9737 > # include <limits.h>
9738 > #else
9739 > # include <assert.h>
9740 > #endif
9741 >
9742 > #undef $ac_func
9743 >
9744 > /* Override any gcc2 internal prototype to avoid an error.  */
9745 > #ifdef __cplusplus
9746 > extern "C"
9747 > {
9748 > #endif
9749 > /* We use char because int might match the return type of a gcc2
9750 >   builtin and then its argument prototype would still apply.  */
9751 > char $ac_func ();
9752 > /* The GNU C library defines this for functions which it implements
9753 >    to always fail with ENOSYS.  Some functions are actually named
9754 >    something starting with __ and the normal name is an alias.  */
9755 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9756 > choke me
9757 > #else
9758 > char (*f) () = $ac_func;
9759 > #endif
9760 > #ifdef __cplusplus
9761 > }
9762 > #endif
9763 >
9764 > #ifdef FC_DUMMY_MAIN
9765 > #ifndef FC_DUMMY_MAIN_EQ_F77
9766 > #  ifdef __cplusplus
9767 >     extern "C"
9768 > #  endif
9769 >   int FC_DUMMY_MAIN() { return 1; }
9770 > #endif
9771 > #endif
9772 > int
9773 > main ()
9774 > {
9775 > return f != $ac_func;
9776 >  ;
9777 >  return 0;
9778 > }
9779 > _ACEOF
9780 > rm -f conftest.$ac_objext conftest$ac_exeext
9781 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9782 >  (eval $ac_link) 2>conftest.er1
9783 >  ac_status=$?
9784 >  grep -v '^ *+' conftest.er1 >conftest.err
9785 >  rm -f conftest.er1
9786 >  cat conftest.err >&5
9787 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9788 >  (exit $ac_status); } &&
9789 >         { ac_try='test -z "$ac_c_werror_flag"
9790 >                         || test ! -s conftest.err'
9791 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9792 >  (eval $ac_try) 2>&5
9793 >  ac_status=$?
9794 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9795 >  (exit $ac_status); }; } &&
9796 >         { ac_try='test -s conftest$ac_exeext'
9797 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9798 >  (eval $ac_try) 2>&5
9799 >  ac_status=$?
9800 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9801 >  (exit $ac_status); }; }; then
9802 >  eval "$as_ac_var=yes"
9803 > else
9804 >  echo "$as_me: failed program was:" >&5
9805 > sed 's/^/| /' conftest.$ac_ext >&5
9806 >
9807 > eval "$as_ac_var=no"
9808 > fi
9809 > rm -f conftest.err conftest.$ac_objext \
9810 >      conftest$ac_exeext conftest.$ac_ext
9811 > fi
9812 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9813 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9814 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9815 >  cat >>confdefs.h <<_ACEOF
9816 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9817 > _ACEOF
9818 >
9819 > else
9820 >  # FreeBSD has a gnugetopt library for this
9821 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
9822 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
9823 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
9824 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9825 > else
9826 >  ac_check_lib_save_LIBS=$LIBS
9827 > LIBS="-lgnugetopt  $LIBS"
9828 > cat >conftest.$ac_ext <<_ACEOF
9829 > /* confdefs.h.  */
9830 > _ACEOF
9831 > cat confdefs.h >>conftest.$ac_ext
9832 > cat >>conftest.$ac_ext <<_ACEOF
9833 > /* end confdefs.h.  */
9834 >
9835 > /* Override any gcc2 internal prototype to avoid an error.  */
9836 > #ifdef __cplusplus
9837 > extern "C"
9838 > #endif
9839 > /* We use char because int might match the return type of a gcc2
9840 >   builtin and then its argument prototype would still apply.  */
9841 > char getopt_long ();
9842 > #ifdef FC_DUMMY_MAIN
9843 > #ifndef FC_DUMMY_MAIN_EQ_F77
9844 > #  ifdef __cplusplus
9845 >     extern "C"
9846 > #  endif
9847 >   int FC_DUMMY_MAIN() { return 1; }
9848 > #endif
9849 > #endif
9850 > int
9851 > main ()
9852 > {
9853 > getopt_long ();
9854 >  ;
9855 >  return 0;
9856 > }
9857 > _ACEOF
9858 > rm -f conftest.$ac_objext conftest$ac_exeext
9859 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9860 >  (eval $ac_link) 2>conftest.er1
9861 >  ac_status=$?
9862 >  grep -v '^ *+' conftest.er1 >conftest.err
9863 >  rm -f conftest.er1
9864 >  cat conftest.err >&5
9865 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9866 >  (exit $ac_status); } &&
9867 >         { ac_try='test -z "$ac_c_werror_flag"
9868 >                         || test ! -s conftest.err'
9869 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9870 >  (eval $ac_try) 2>&5
9871 >  ac_status=$?
9872 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9873 >  (exit $ac_status); }; } &&
9874 >         { ac_try='test -s conftest$ac_exeext'
9875 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9876 >  (eval $ac_try) 2>&5
9877 >  ac_status=$?
9878 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9879 >  (exit $ac_status); }; }; then
9880 >  ac_cv_lib_gnugetopt_getopt_long=yes
9881 > else
9882 >  echo "$as_me: failed program was:" >&5
9883 > sed 's/^/| /' conftest.$ac_ext >&5
9884 >
9885 > ac_cv_lib_gnugetopt_getopt_long=no
9886 > fi
9887 > rm -f conftest.err conftest.$ac_objext \
9888 >      conftest$ac_exeext conftest.$ac_ext
9889 > LIBS=$ac_check_lib_save_LIBS
9890 > fi
9891 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
9892 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
9893 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
9894 >  cat >>confdefs.h <<\_ACEOF
9895 > #define HAVE_GETOPT_LONG 1
9896 > _ACEOF
9897 >
9898 > else
9899 >  # use the GNU replacement
9900 >      case $LIBOBJS in
9901 >    "getopt.$ac_objext"   | \
9902 >  *" getopt.$ac_objext"   | \
9903 >    "getopt.$ac_objext "* | \
9904 >  *" getopt.$ac_objext "* ) ;;
9905 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
9906 > esac
9907 >
9908 >      case $LIBOBJS in
9909 >    "getopt1.$ac_objext"   | \
9910 >  *" getopt1.$ac_objext"   | \
9911 >    "getopt1.$ac_objext "* | \
9912 >  *" getopt1.$ac_objext "* ) ;;
9913 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
9914 > esac
9915 >
9916 >                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
9917 >
9918 > fi
9919 >
9920 > fi
9921 > done
9922 >
9923 >
9924 > ac_ext=cc
9925 > ac_cpp='$CXXCPP $CPPFLAGS'
9926 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9927 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9928 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9929 >
9930 >
9931 > echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
9932 > echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
9933 > if test "${ac_cv_cxx_namespaces+set}" = set; then
9934 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9935 > else
9936 >
9937 >
9938 > ac_ext=cc
9939 > ac_cpp='$CXXCPP $CPPFLAGS'
9940 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9941 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9942 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9943 >
9944 > cat >conftest.$ac_ext <<_ACEOF
9945 > /* confdefs.h.  */
9946 > _ACEOF
9947 > cat confdefs.h >>conftest.$ac_ext
9948 > cat >>conftest.$ac_ext <<_ACEOF
9949 > /* end confdefs.h.  */
9950 > namespace Outer { namespace Inner { int i = 0; }}
9951 > #ifdef FC_DUMMY_MAIN
9952 > #ifndef FC_DUMMY_MAIN_EQ_F77
9953 > #  ifdef __cplusplus
9954 >     extern "C"
9955 > #  endif
9956 >   int FC_DUMMY_MAIN() { return 1; }
9957 > #endif
9958 > #endif
9959 > int
9960 > main ()
9961 > {
9962 > using namespace Outer::Inner; return i;
9963 >  ;
9964 >  return 0;
9965 > }
9966 > _ACEOF
9967 > rm -f conftest.$ac_objext
9968 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9969 >  (eval $ac_compile) 2>conftest.er1
9970 >  ac_status=$?
9971 >  grep -v '^ *+' conftest.er1 >conftest.err
9972 >  rm -f conftest.er1
9973 >  cat conftest.err >&5
9974 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9975 >  (exit $ac_status); } &&
9976 >         { ac_try='test -z "$ac_cxx_werror_flag"
9977 >                         || test ! -s conftest.err'
9978 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9979 >  (eval $ac_try) 2>&5
9980 >  ac_status=$?
9981 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9982 >  (exit $ac_status); }; } &&
9983 >         { ac_try='test -s conftest.$ac_objext'
9984 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9985 >  (eval $ac_try) 2>&5
9986 >  ac_status=$?
9987 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9988 >  (exit $ac_status); }; }; then
9989 >  ac_cv_cxx_namespaces=yes
9990 > else
9991 >  echo "$as_me: failed program was:" >&5
9992 > sed 's/^/| /' conftest.$ac_ext >&5
9993 >
9994 > ac_cv_cxx_namespaces=no
9995 > fi
9996 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9997 > ac_ext=cc
9998 > ac_cpp='$CXXCPP $CPPFLAGS'
9999 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10000 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10001 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10002 >
10003 >
10004 > fi
10005 > echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10006 > echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10007 > if test "$ac_cv_cxx_namespaces" = yes; then
10008 >
10009 > cat >>confdefs.h <<\_ACEOF
10010 > #define HAVE_NAMESPACES
10011 > _ACEOF
10012 >
10013 > fi
10014 >
10015 > ac_ext=cc
10016 > ac_cpp='$CXXCPP $CPPFLAGS'
10017 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10018 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10019 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10020 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10021 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10022 > if test -z "$CXXCPP"; then
10023 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10024 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10025 > else
10026 >      # Double quotes because CXXCPP needs to be expanded
10027 >    for CXXCPP in "$CXX -E" "/lib/cpp"
10028 >    do
10029 >      ac_preproc_ok=false
10030 > for ac_cxx_preproc_warn_flag in '' yes
10031 > do
10032 >  # Use a header file that comes with gcc, so configuring glibc
10033 >  # with a fresh cross-compiler works.
10034 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10035 >  # <limits.h> exists even on freestanding compilers.
10036 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10037 >  # not just through cpp. "Syntax error" is here to catch this case.
10038 >  cat >conftest.$ac_ext <<_ACEOF
10039 > /* confdefs.h.  */
10040 > _ACEOF
10041 > cat confdefs.h >>conftest.$ac_ext
10042 > cat >>conftest.$ac_ext <<_ACEOF
10043 > /* end confdefs.h.  */
10044 > #ifdef __STDC__
10045 > # include <limits.h>
10046 > #else
10047 > # include <assert.h>
10048 > #endif
10049 >                     Syntax error
10050 > _ACEOF
10051 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10052 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10053 >  ac_status=$?
10054 >  grep -v '^ *+' conftest.er1 >conftest.err
10055 >  rm -f conftest.er1
10056 >  cat conftest.err >&5
10057 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10058 >  (exit $ac_status); } >/dev/null; then
10059 >  if test -s conftest.err; then
10060 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10061 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10062 >  else
10063 >    ac_cpp_err=
10064 >  fi
10065 > else
10066 >  ac_cpp_err=yes
10067 > fi
10068 > if test -z "$ac_cpp_err"; then
10069 >  :
10070 > else
10071 >  echo "$as_me: failed program was:" >&5
10072 > sed 's/^/| /' conftest.$ac_ext >&5
10073 >
10074 >  # Broken: fails on valid input.
10075 > continue
10076 > fi
10077 > rm -f conftest.err conftest.$ac_ext
10078 >
10079 >  # OK, works on sane cases.  Now check whether non-existent headers
10080 >  # can be detected and how.
10081 >  cat >conftest.$ac_ext <<_ACEOF
10082 > /* confdefs.h.  */
10083 > _ACEOF
10084 > cat confdefs.h >>conftest.$ac_ext
10085 > cat >>conftest.$ac_ext <<_ACEOF
10086 > /* end confdefs.h.  */
10087 > #include <ac_nonexistent.h>
10088 > _ACEOF
10089 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10090 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10091 >  ac_status=$?
10092 >  grep -v '^ *+' conftest.er1 >conftest.err
10093 >  rm -f conftest.er1
10094 >  cat conftest.err >&5
10095 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10096 >  (exit $ac_status); } >/dev/null; then
10097 >  if test -s conftest.err; then
10098 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10099 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10100 >  else
10101 >    ac_cpp_err=
10102 >  fi
10103 > else
10104 >  ac_cpp_err=yes
10105 > fi
10106 > if test -z "$ac_cpp_err"; then
10107 >  # Broken: success on invalid input.
10108 > continue
10109 > else
10110 >  echo "$as_me: failed program was:" >&5
10111 > sed 's/^/| /' conftest.$ac_ext >&5
10112 >
10113 >  # Passes both tests.
10114 > ac_preproc_ok=:
10115 > break
10116 > fi
10117 > rm -f conftest.err conftest.$ac_ext
10118 >
10119 > done
10120 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10121 > rm -f conftest.err conftest.$ac_ext
10122 > if $ac_preproc_ok; then
10123 >  break
10124 > fi
10125 >
10126 >    done
10127 >    ac_cv_prog_CXXCPP=$CXXCPP
10128 >
10129 > fi
10130 >  CXXCPP=$ac_cv_prog_CXXCPP
10131 > else
10132 >  ac_cv_prog_CXXCPP=$CXXCPP
10133 > fi
10134 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10135 > echo "${ECHO_T}$CXXCPP" >&6
10136 > ac_preproc_ok=false
10137 > for ac_cxx_preproc_warn_flag in '' yes
10138 > do
10139 >  # Use a header file that comes with gcc, so configuring glibc
10140 >  # with a fresh cross-compiler works.
10141 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10142 >  # <limits.h> exists even on freestanding compilers.
10143 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10144 >  # not just through cpp. "Syntax error" is here to catch this case.
10145 >  cat >conftest.$ac_ext <<_ACEOF
10146 > /* confdefs.h.  */
10147 > _ACEOF
10148 > cat confdefs.h >>conftest.$ac_ext
10149 > cat >>conftest.$ac_ext <<_ACEOF
10150 > /* end confdefs.h.  */
10151 > #ifdef __STDC__
10152 > # include <limits.h>
10153 > #else
10154 > # include <assert.h>
10155 > #endif
10156 >                     Syntax error
10157 > _ACEOF
10158 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10159 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10160 >  ac_status=$?
10161 >  grep -v '^ *+' conftest.er1 >conftest.err
10162 >  rm -f conftest.er1
10163 >  cat conftest.err >&5
10164 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10165 >  (exit $ac_status); } >/dev/null; then
10166 >  if test -s conftest.err; then
10167 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10168 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10169 >  else
10170 >    ac_cpp_err=
10171 >  fi
10172 > else
10173 >  ac_cpp_err=yes
10174 > fi
10175 > if test -z "$ac_cpp_err"; then
10176 >  :
10177 > else
10178 >  echo "$as_me: failed program was:" >&5
10179 > sed 's/^/| /' conftest.$ac_ext >&5
10180 >
10181 >  # Broken: fails on valid input.
10182 > continue
10183 > fi
10184 > rm -f conftest.err conftest.$ac_ext
10185 >
10186 >  # OK, works on sane cases.  Now check whether non-existent headers
10187 >  # can be detected and how.
10188 >  cat >conftest.$ac_ext <<_ACEOF
10189 > /* confdefs.h.  */
10190 > _ACEOF
10191 > cat confdefs.h >>conftest.$ac_ext
10192 > cat >>conftest.$ac_ext <<_ACEOF
10193 > /* end confdefs.h.  */
10194 > #include <ac_nonexistent.h>
10195 > _ACEOF
10196 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10197 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10198 >  ac_status=$?
10199 >  grep -v '^ *+' conftest.er1 >conftest.err
10200 >  rm -f conftest.er1
10201 >  cat conftest.err >&5
10202 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10203 >  (exit $ac_status); } >/dev/null; then
10204 >  if test -s conftest.err; then
10205 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10206 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10207 >  else
10208 >    ac_cpp_err=
10209 >  fi
10210 > else
10211 >  ac_cpp_err=yes
10212 > fi
10213 > if test -z "$ac_cpp_err"; then
10214 >  # Broken: success on invalid input.
10215 > continue
10216 > else
10217 >  echo "$as_me: failed program was:" >&5
10218 > sed 's/^/| /' conftest.$ac_ext >&5
10219 >
10220 >  # Passes both tests.
10221 > ac_preproc_ok=:
10222 > break
10223 > fi
10224 > rm -f conftest.err conftest.$ac_ext
10225 >
10226 > done
10227 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10228 > rm -f conftest.err conftest.$ac_ext
10229 > if $ac_preproc_ok; then
10230 >  :
10231 > else
10232 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10233 > See \`config.log' for more details." >&5
10234 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10235 > See \`config.log' for more details." >&2;}
10236 >   { (exit 1); exit 1; }; }
10237 > fi
10238 >
10239 > ac_ext=cc
10240 > ac_cpp='$CXXCPP $CPPFLAGS'
10241 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10242 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10243 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10244 >
10245 >
10246 > echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10247 > echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10248 > if test "${ac_cv_cxx_have_stl+set}" = set; then
10249 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10250 > else
10251 >
10252 >
10253 >
10254 > ac_ext=cc
10255 > ac_cpp='$CXXCPP $CPPFLAGS'
10256 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10257 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10258 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10259 >
10260 > cat >conftest.$ac_ext <<_ACEOF
10261 > /* confdefs.h.  */
10262 > _ACEOF
10263 > cat confdefs.h >>conftest.$ac_ext
10264 > cat >>conftest.$ac_ext <<_ACEOF
10265 > /* end confdefs.h.  */
10266 > #include <list>
10267 > #include <deque>
10268 > #ifdef HAVE_NAMESPACES
10269 > using namespace std;
10270 > #endif
10271 > #ifdef FC_DUMMY_MAIN
10272 > #ifndef FC_DUMMY_MAIN_EQ_F77
10273 > #  ifdef __cplusplus
10274 >     extern "C"
10275 > #  endif
10276 >   int FC_DUMMY_MAIN() { return 1; }
10277 > #endif
10278 > #endif
10279 > int
10280 > main ()
10281 > {
10282 > list<int> x; x.push_back(5);
10283 > list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10284 >  ;
10285 >  return 0;
10286 > }
10287 > _ACEOF
10288 > rm -f conftest.$ac_objext
10289 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10290 >  (eval $ac_compile) 2>conftest.er1
10291 >  ac_status=$?
10292 >  grep -v '^ *+' conftest.er1 >conftest.err
10293 >  rm -f conftest.er1
10294 >  cat conftest.err >&5
10295 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10296 >  (exit $ac_status); } &&
10297 >         { ac_try='test -z "$ac_cxx_werror_flag"
10298 >                         || test ! -s conftest.err'
10299 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10300 >  (eval $ac_try) 2>&5
10301 >  ac_status=$?
10302 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10303 >  (exit $ac_status); }; } &&
10304 >         { ac_try='test -s conftest.$ac_objext'
10305 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10306 >  (eval $ac_try) 2>&5
10307 >  ac_status=$?
10308 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10309 >  (exit $ac_status); }; }; then
10310 >  ac_cv_cxx_have_stl=yes
10311 > else
10312 >  echo "$as_me: failed program was:" >&5
10313 > sed 's/^/| /' conftest.$ac_ext >&5
10314 >
10315 > ac_cv_cxx_have_stl=no
10316 > fi
10317 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10318 > ac_ext=cc
10319 > ac_cpp='$CXXCPP $CPPFLAGS'
10320 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10321 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10322 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10323 >
10324 >
10325 > fi
10326 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10327 > echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10328 > if test "$ac_cv_cxx_have_stl" = yes; then
10329 >
10330 > cat >>confdefs.h <<\_ACEOF
10331 > #define HAVE_STL
10332 > _ACEOF
10333 >
10334 > fi
10335 >
10336 >
10337 >
10338 >  if test "${ac_cv_header_iostream+set}" = set; then
10339 >  echo "$as_me:$LINENO: checking for iostream" >&5
10340 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10341 > if test "${ac_cv_header_iostream+set}" = set; then
10342 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10343 > fi
10344 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10345 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10346 > else
10347 >  # Is the header compilable?
10348 > echo "$as_me:$LINENO: checking iostream usability" >&5
10349 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10350 > cat >conftest.$ac_ext <<_ACEOF
10351 > /* confdefs.h.  */
10352 > _ACEOF
10353 > cat confdefs.h >>conftest.$ac_ext
10354 > cat >>conftest.$ac_ext <<_ACEOF
10355 > /* end confdefs.h.  */
10356 > $ac_includes_default
10357 > #include <iostream>
10358 > _ACEOF
10359 > rm -f conftest.$ac_objext
10360 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10361 >  (eval $ac_compile) 2>conftest.er1
10362 >  ac_status=$?
10363 >  grep -v '^ *+' conftest.er1 >conftest.err
10364 >  rm -f conftest.er1
10365 >  cat conftest.err >&5
10366 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10367 >  (exit $ac_status); } &&
10368 >         { ac_try='test -z "$ac_cxx_werror_flag"
10369 >                         || test ! -s conftest.err'
10370 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10371 >  (eval $ac_try) 2>&5
10372 >  ac_status=$?
10373 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10374 >  (exit $ac_status); }; } &&
10375 >         { ac_try='test -s conftest.$ac_objext'
10376 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10377 >  (eval $ac_try) 2>&5
10378 >  ac_status=$?
10379 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10380 >  (exit $ac_status); }; }; then
10381 >  ac_header_compiler=yes
10382 > else
10383 >  echo "$as_me: failed program was:" >&5
10384 > sed 's/^/| /' conftest.$ac_ext >&5
10385 >
10386 > ac_header_compiler=no
10387 > fi
10388 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10389 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10390 > echo "${ECHO_T}$ac_header_compiler" >&6
10391 >
10392 > # Is the header present?
10393 > echo "$as_me:$LINENO: checking iostream presence" >&5
10394 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10395 > cat >conftest.$ac_ext <<_ACEOF
10396 > /* confdefs.h.  */
10397 > _ACEOF
10398 > cat confdefs.h >>conftest.$ac_ext
10399 > cat >>conftest.$ac_ext <<_ACEOF
10400 > /* end confdefs.h.  */
10401 > #include <iostream>
10402 > _ACEOF
10403 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10404 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10405 >  ac_status=$?
10406 >  grep -v '^ *+' conftest.er1 >conftest.err
10407 >  rm -f conftest.er1
10408 >  cat conftest.err >&5
10409 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10410 >  (exit $ac_status); } >/dev/null; then
10411 >  if test -s conftest.err; then
10412 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10413 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10414 >  else
10415 >    ac_cpp_err=
10416 >  fi
10417 > else
10418 >  ac_cpp_err=yes
10419 > fi
10420 > if test -z "$ac_cpp_err"; then
10421 >  ac_header_preproc=yes
10422 > else
10423 >  echo "$as_me: failed program was:" >&5
10424 > sed 's/^/| /' conftest.$ac_ext >&5
10425 >
10426 >  ac_header_preproc=no
10427 > fi
10428 > rm -f conftest.err conftest.$ac_ext
10429 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10430 > echo "${ECHO_T}$ac_header_preproc" >&6
10431 >
10432 > # So?  What about this header?
10433 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10434 >  yes:no: )
10435 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10436 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10437 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10438 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10439 >    ac_header_preproc=yes
10440 >    ;;
10441 >  no:yes:* )
10442 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10443 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10444 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10445 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10446 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10447 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10448 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10449 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10450 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10451 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10452 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10453 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10454 >    (
10455 >      cat <<\_ASBOX
10456 > ## ------------------------------ ##
10457 > ## Report this to gezelter@nd.edu ##
10458 > ## ------------------------------ ##
10459 > _ASBOX
10460 >    ) |
10461 >      sed "s/^/$as_me: WARNING:     /" >&2
10462 >    ;;
10463 > esac
10464 > echo "$as_me:$LINENO: checking for iostream" >&5
10465 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10466 > if test "${ac_cv_header_iostream+set}" = set; then
10467 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10468 > else
10469 >  ac_cv_header_iostream=$ac_header_preproc
10470 > fi
10471 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10472 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10473 >
10474 > fi
10475 > if test $ac_cv_header_iostream = yes; then
10476 >
10477 >
10478 > cat >>confdefs.h <<\_ACEOF
10479 > #define HAVE_IOSTREAM 1
10480 > _ACEOF
10481 >
10482 >
10483 > else
10484 >
10485 >
10486 > for ac_header in iostream.h
10487 > do
10488 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10489 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10490 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10491 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10492 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10493 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10494 > fi
10495 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10496 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10497 > else
10498 >  # Is the header compilable?
10499 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10500 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10501 > cat >conftest.$ac_ext <<_ACEOF
10502 > /* confdefs.h.  */
10503 > _ACEOF
10504 > cat confdefs.h >>conftest.$ac_ext
10505 > cat >>conftest.$ac_ext <<_ACEOF
10506 > /* end confdefs.h.  */
10507 > $ac_includes_default
10508 > #include <$ac_header>
10509 > _ACEOF
10510 > rm -f conftest.$ac_objext
10511 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10512 >  (eval $ac_compile) 2>conftest.er1
10513 >  ac_status=$?
10514 >  grep -v '^ *+' conftest.er1 >conftest.err
10515 >  rm -f conftest.er1
10516 >  cat conftest.err >&5
10517 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10518 >  (exit $ac_status); } &&
10519 >         { ac_try='test -z "$ac_cxx_werror_flag"
10520 >                         || test ! -s conftest.err'
10521 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10522 >  (eval $ac_try) 2>&5
10523 >  ac_status=$?
10524 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10525 >  (exit $ac_status); }; } &&
10526 >         { ac_try='test -s conftest.$ac_objext'
10527 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10528 >  (eval $ac_try) 2>&5
10529 >  ac_status=$?
10530 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10531 >  (exit $ac_status); }; }; then
10532 >  ac_header_compiler=yes
10533 > else
10534 >  echo "$as_me: failed program was:" >&5
10535 > sed 's/^/| /' conftest.$ac_ext >&5
10536 >
10537 > ac_header_compiler=no
10538 > fi
10539 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10540 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10541 > echo "${ECHO_T}$ac_header_compiler" >&6
10542 >
10543 > # Is the header present?
10544 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10545 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10546 > cat >conftest.$ac_ext <<_ACEOF
10547 > /* confdefs.h.  */
10548 > _ACEOF
10549 > cat confdefs.h >>conftest.$ac_ext
10550 > cat >>conftest.$ac_ext <<_ACEOF
10551 > /* end confdefs.h.  */
10552 > #include <$ac_header>
10553 > _ACEOF
10554 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10555 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10556 >  ac_status=$?
10557 >  grep -v '^ *+' conftest.er1 >conftest.err
10558 >  rm -f conftest.er1
10559 >  cat conftest.err >&5
10560 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10561 >  (exit $ac_status); } >/dev/null; then
10562 >  if test -s conftest.err; then
10563 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10564 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10565 >  else
10566 >    ac_cpp_err=
10567 >  fi
10568 > else
10569 >  ac_cpp_err=yes
10570 > fi
10571 > if test -z "$ac_cpp_err"; then
10572 >  ac_header_preproc=yes
10573 > else
10574 >  echo "$as_me: failed program was:" >&5
10575 > sed 's/^/| /' conftest.$ac_ext >&5
10576 >
10577 >  ac_header_preproc=no
10578 > fi
10579 > rm -f conftest.err conftest.$ac_ext
10580 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10581 > echo "${ECHO_T}$ac_header_preproc" >&6
10582 >
10583 > # So?  What about this header?
10584 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10585 >  yes:no: )
10586 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10587 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10588 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10589 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10590 >    ac_header_preproc=yes
10591 >    ;;
10592 >  no:yes:* )
10593 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10594 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10595 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10596 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10597 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10598 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10599 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10600 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10601 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10602 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10603 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10604 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10605 >    (
10606 >      cat <<\_ASBOX
10607 > ## ------------------------------ ##
10608 > ## Report this to gezelter@nd.edu ##
10609 > ## ------------------------------ ##
10610 > _ASBOX
10611 >    ) |
10612 >      sed "s/^/$as_me: WARNING:     /" >&2
10613 >    ;;
10614 > esac
10615 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10616 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10617 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10618 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10619 > else
10620 >  eval "$as_ac_Header=\$ac_header_preproc"
10621 > fi
10622 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10623 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10624 >
10625 > fi
10626 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10627 >  cat >>confdefs.h <<_ACEOF
10628 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10629 > _ACEOF
10630 >
10631 > fi
10632 >
10633 > done
10634 >
10635 >
10636 > fi
10637 >
10638 >
10639 >
10640 >
10641 >  if test "${ac_cv_header_iomanip+set}" = set; then
10642 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10643 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10644 > if test "${ac_cv_header_iomanip+set}" = set; then
10645 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10646 > fi
10647 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10648 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10649 > else
10650 >  # Is the header compilable?
10651 > echo "$as_me:$LINENO: checking iomanip usability" >&5
10652 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10653 > cat >conftest.$ac_ext <<_ACEOF
10654 > /* confdefs.h.  */
10655 > _ACEOF
10656 > cat confdefs.h >>conftest.$ac_ext
10657 > cat >>conftest.$ac_ext <<_ACEOF
10658 > /* end confdefs.h.  */
10659 > $ac_includes_default
10660 > #include <iomanip>
10661 > _ACEOF
10662 > rm -f conftest.$ac_objext
10663 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10664 >  (eval $ac_compile) 2>conftest.er1
10665 >  ac_status=$?
10666 >  grep -v '^ *+' conftest.er1 >conftest.err
10667 >  rm -f conftest.er1
10668 >  cat conftest.err >&5
10669 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10670 >  (exit $ac_status); } &&
10671 >         { ac_try='test -z "$ac_cxx_werror_flag"
10672 >                         || test ! -s conftest.err'
10673 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10674 >  (eval $ac_try) 2>&5
10675 >  ac_status=$?
10676 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10677 >  (exit $ac_status); }; } &&
10678 >         { ac_try='test -s conftest.$ac_objext'
10679 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10680 >  (eval $ac_try) 2>&5
10681 >  ac_status=$?
10682 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10683 >  (exit $ac_status); }; }; then
10684 >  ac_header_compiler=yes
10685 > else
10686 >  echo "$as_me: failed program was:" >&5
10687 > sed 's/^/| /' conftest.$ac_ext >&5
10688 >
10689 > ac_header_compiler=no
10690 > fi
10691 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10692 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10693 > echo "${ECHO_T}$ac_header_compiler" >&6
10694 >
10695 > # Is the header present?
10696 > echo "$as_me:$LINENO: checking iomanip presence" >&5
10697 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
10698 > cat >conftest.$ac_ext <<_ACEOF
10699 > /* confdefs.h.  */
10700 > _ACEOF
10701 > cat confdefs.h >>conftest.$ac_ext
10702 > cat >>conftest.$ac_ext <<_ACEOF
10703 > /* end confdefs.h.  */
10704 > #include <iomanip>
10705 > _ACEOF
10706 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10707 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10708 >  ac_status=$?
10709 >  grep -v '^ *+' conftest.er1 >conftest.err
10710 >  rm -f conftest.er1
10711 >  cat conftest.err >&5
10712 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10713 >  (exit $ac_status); } >/dev/null; then
10714 >  if test -s conftest.err; then
10715 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10716 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10717 >  else
10718 >    ac_cpp_err=
10719 >  fi
10720 > else
10721 >  ac_cpp_err=yes
10722 > fi
10723 > if test -z "$ac_cpp_err"; then
10724 >  ac_header_preproc=yes
10725 > else
10726 >  echo "$as_me: failed program was:" >&5
10727 > sed 's/^/| /' conftest.$ac_ext >&5
10728 >
10729 >  ac_header_preproc=no
10730 > fi
10731 > rm -f conftest.err conftest.$ac_ext
10732 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10733 > echo "${ECHO_T}$ac_header_preproc" >&6
10734 >
10735 > # So?  What about this header?
10736 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10737 >  yes:no: )
10738 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
10739 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
10740 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
10741 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
10742 >    ac_header_preproc=yes
10743 >    ;;
10744 >  no:yes:* )
10745 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
10746 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
10747 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
10748 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
10749 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
10750 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
10751 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
10752 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
10753 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
10754 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
10755 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
10756 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
10757 >    (
10758 >      cat <<\_ASBOX
10759 > ## ------------------------------ ##
10760 > ## Report this to gezelter@nd.edu ##
10761 > ## ------------------------------ ##
10762 > _ASBOX
10763 >    ) |
10764 >      sed "s/^/$as_me: WARNING:     /" >&2
10765 >    ;;
10766 > esac
10767 > echo "$as_me:$LINENO: checking for iomanip" >&5
10768 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10769 > if test "${ac_cv_header_iomanip+set}" = set; then
10770 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10771 > else
10772 >  ac_cv_header_iomanip=$ac_header_preproc
10773 > fi
10774 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10775 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10776 >
10777 > fi
10778 > if test $ac_cv_header_iomanip = yes; then
10779 >
10780 >
10781 > cat >>confdefs.h <<\_ACEOF
10782 > #define HAVE_IOMANIP 1
10783 > _ACEOF
10784 >
10785 >
10786 > else
10787 >
10788 >
10789 > for ac_header in iomanip.h
10790 > do
10791 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10792 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10793 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10794 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10795 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10796 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10797 > fi
10798 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10799 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10800 > else
10801 >  # Is the header compilable?
10802 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10803 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10804 > cat >conftest.$ac_ext <<_ACEOF
10805 > /* confdefs.h.  */
10806 > _ACEOF
10807 > cat confdefs.h >>conftest.$ac_ext
10808 > cat >>conftest.$ac_ext <<_ACEOF
10809 > /* end confdefs.h.  */
10810 > $ac_includes_default
10811 > #include <$ac_header>
10812 > _ACEOF
10813 > rm -f conftest.$ac_objext
10814 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10815 >  (eval $ac_compile) 2>conftest.er1
10816 >  ac_status=$?
10817 >  grep -v '^ *+' conftest.er1 >conftest.err
10818 >  rm -f conftest.er1
10819 >  cat conftest.err >&5
10820 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10821 >  (exit $ac_status); } &&
10822 >         { ac_try='test -z "$ac_cxx_werror_flag"
10823 >                         || test ! -s conftest.err'
10824 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10825 >  (eval $ac_try) 2>&5
10826 >  ac_status=$?
10827 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10828 >  (exit $ac_status); }; } &&
10829 >         { ac_try='test -s conftest.$ac_objext'
10830 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10831 >  (eval $ac_try) 2>&5
10832 >  ac_status=$?
10833 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10834 >  (exit $ac_status); }; }; then
10835 >  ac_header_compiler=yes
10836 > else
10837 >  echo "$as_me: failed program was:" >&5
10838 > sed 's/^/| /' conftest.$ac_ext >&5
10839 >
10840 > ac_header_compiler=no
10841 > fi
10842 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10843 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10844 > echo "${ECHO_T}$ac_header_compiler" >&6
10845 >
10846 > # Is the header present?
10847 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10848 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10849 > cat >conftest.$ac_ext <<_ACEOF
10850 > /* confdefs.h.  */
10851 > _ACEOF
10852 > cat confdefs.h >>conftest.$ac_ext
10853 > cat >>conftest.$ac_ext <<_ACEOF
10854 > /* end confdefs.h.  */
10855 > #include <$ac_header>
10856 > _ACEOF
10857 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10858 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10859 >  ac_status=$?
10860 >  grep -v '^ *+' conftest.er1 >conftest.err
10861 >  rm -f conftest.er1
10862 >  cat conftest.err >&5
10863 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10864 >  (exit $ac_status); } >/dev/null; then
10865 >  if test -s conftest.err; then
10866 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10867 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10868 >  else
10869 >    ac_cpp_err=
10870 >  fi
10871 > else
10872 >  ac_cpp_err=yes
10873 > fi
10874 > if test -z "$ac_cpp_err"; then
10875 >  ac_header_preproc=yes
10876 > else
10877 >  echo "$as_me: failed program was:" >&5
10878 > sed 's/^/| /' conftest.$ac_ext >&5
10879 >
10880 >  ac_header_preproc=no
10881 > fi
10882 > rm -f conftest.err conftest.$ac_ext
10883 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10884 > echo "${ECHO_T}$ac_header_preproc" >&6
10885 >
10886 > # So?  What about this header?
10887 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10888 >  yes:no: )
10889 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10890 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10891 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10892 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10893 >    ac_header_preproc=yes
10894 >    ;;
10895 >  no:yes:* )
10896 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10897 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10898 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10899 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10900 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10901 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10902 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10903 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10904 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10905 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10906 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10907 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10908 >    (
10909 >      cat <<\_ASBOX
10910 > ## ------------------------------ ##
10911 > ## Report this to gezelter@nd.edu ##
10912 > ## ------------------------------ ##
10913 > _ASBOX
10914 >    ) |
10915 >      sed "s/^/$as_me: WARNING:     /" >&2
10916 >    ;;
10917 > esac
10918 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10919 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10920 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10921 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10922 > else
10923 >  eval "$as_ac_Header=\$ac_header_preproc"
10924 > fi
10925 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10926 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10927 >
10928 > fi
10929 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10930 >  cat >>confdefs.h <<_ACEOF
10931 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10932 > _ACEOF
10933 >
10934 > fi
10935 >
10936 > done
10937 >
10938 >
10939 > fi
10940 >
10941 >
10942 >
10943 >
10944 > for ac_header in cmath
10945 > do
10946 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10947 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10948 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10949 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10950 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10951 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10952 > fi
10953 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10954 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10955 > else
10956 >  # Is the header compilable?
10957 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10958 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10959 > cat >conftest.$ac_ext <<_ACEOF
10960 > /* confdefs.h.  */
10961 > _ACEOF
10962 > cat confdefs.h >>conftest.$ac_ext
10963 > cat >>conftest.$ac_ext <<_ACEOF
10964 > /* end confdefs.h.  */
10965 > $ac_includes_default
10966 > #include <$ac_header>
10967 > _ACEOF
10968 > rm -f conftest.$ac_objext
10969 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10970 >  (eval $ac_compile) 2>conftest.er1
10971 >  ac_status=$?
10972 >  grep -v '^ *+' conftest.er1 >conftest.err
10973 >  rm -f conftest.er1
10974 >  cat conftest.err >&5
10975 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10976 >  (exit $ac_status); } &&
10977 >         { ac_try='test -z "$ac_cxx_werror_flag"
10978 >                         || test ! -s conftest.err'
10979 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10980 >  (eval $ac_try) 2>&5
10981 >  ac_status=$?
10982 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10983 >  (exit $ac_status); }; } &&
10984 >         { ac_try='test -s conftest.$ac_objext'
10985 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10986 >  (eval $ac_try) 2>&5
10987 >  ac_status=$?
10988 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10989 >  (exit $ac_status); }; }; then
10990 >  ac_header_compiler=yes
10991 > else
10992 >  echo "$as_me: failed program was:" >&5
10993 > sed 's/^/| /' conftest.$ac_ext >&5
10994 >
10995 > ac_header_compiler=no
10996 > fi
10997 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10998 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10999 > echo "${ECHO_T}$ac_header_compiler" >&6
11000 >
11001 > # Is the header present?
11002 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
11003 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11004 > cat >conftest.$ac_ext <<_ACEOF
11005 > /* confdefs.h.  */
11006 > _ACEOF
11007 > cat confdefs.h >>conftest.$ac_ext
11008 > cat >>conftest.$ac_ext <<_ACEOF
11009 > /* end confdefs.h.  */
11010 > #include <$ac_header>
11011 > _ACEOF
11012 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11013 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11014 >  ac_status=$?
11015 >  grep -v '^ *+' conftest.er1 >conftest.err
11016 >  rm -f conftest.er1
11017 >  cat conftest.err >&5
11018 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11019 >  (exit $ac_status); } >/dev/null; then
11020 >  if test -s conftest.err; then
11021 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11022 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11023 >  else
11024 >    ac_cpp_err=
11025 >  fi
11026 > else
11027 >  ac_cpp_err=yes
11028 > fi
11029 > if test -z "$ac_cpp_err"; then
11030 >  ac_header_preproc=yes
11031 > else
11032 >  echo "$as_me: failed program was:" >&5
11033 > sed 's/^/| /' conftest.$ac_ext >&5
11034 >
11035 >  ac_header_preproc=no
11036 > fi
11037 > rm -f conftest.err conftest.$ac_ext
11038 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11039 > echo "${ECHO_T}$ac_header_preproc" >&6
11040 >
11041 > # So?  What about this header?
11042 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11043 >  yes:no: )
11044 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11045 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11046 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11047 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11048 >    ac_header_preproc=yes
11049 >    ;;
11050 >  no:yes:* )
11051 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11052 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11053 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11054 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11055 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11056 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11057 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11058 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11059 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11060 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11061 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11062 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11063 >    (
11064 >      cat <<\_ASBOX
11065 > ## ------------------------------ ##
11066 > ## Report this to gezelter@nd.edu ##
11067 > ## ------------------------------ ##
11068 > _ASBOX
11069 >    ) |
11070 >      sed "s/^/$as_me: WARNING:     /" >&2
11071 >    ;;
11072 > esac
11073 > echo "$as_me:$LINENO: checking for $ac_header" >&5
11074 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11075 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11076 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11077 > else
11078 >  eval "$as_ac_Header=\$ac_header_preproc"
11079 > fi
11080 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11081 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11082 >
11083 > fi
11084 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
11085 >  cat >>confdefs.h <<_ACEOF
11086 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11087 > _ACEOF
11088 >
11089 > fi
11090 >
11091 > done
11092 >
11093 >
11094 >
11095 >
11096 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11097 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11098 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11099 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11100 > else
11101 >
11102 >      ac_cv_cxx_have_std_iostream=no
11103 >      ac_cv_cxx_need_use_std_iostream=no
11104 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11105 >
11106 >
11107 >        ac_ext=cc
11108 > ac_cpp='$CXXCPP $CPPFLAGS'
11109 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11110 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11111 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11112 >
11113 >        cat >conftest.$ac_ext <<_ACEOF
11114 > /* confdefs.h.  */
11115 > _ACEOF
11116 > cat confdefs.h >>conftest.$ac_ext
11117 > cat >>conftest.$ac_ext <<_ACEOF
11118 > /* end confdefs.h.  */
11119 >
11120 > #ifdef HAVE_IOSTREAM
11121 > #include <iostream>
11122 > #else
11123 > #include <iostream.h>
11124 > #endif
11125 >
11126 > #ifdef FC_DUMMY_MAIN
11127 > #ifndef FC_DUMMY_MAIN_EQ_F77
11128 > #  ifdef __cplusplus
11129 >     extern "C"
11130 > #  endif
11131 >   int FC_DUMMY_MAIN() { return 1; }
11132 > #endif
11133 > #endif
11134 > int
11135 > main ()
11136 > {
11137 > std::cout<<"Hello World"<<std::endl;return 0;
11138 >  ;
11139 >  return 0;
11140 > }
11141 > _ACEOF
11142 > rm -f conftest.$ac_objext
11143 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11144 >  (eval $ac_compile) 2>conftest.er1
11145 >  ac_status=$?
11146 >  grep -v '^ *+' conftest.er1 >conftest.err
11147 >  rm -f conftest.er1
11148 >  cat conftest.err >&5
11149 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11150 >  (exit $ac_status); } &&
11151 >         { ac_try='test -z "$ac_cxx_werror_flag"
11152 >                         || test ! -s conftest.err'
11153 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11154 >  (eval $ac_try) 2>&5
11155 >  ac_status=$?
11156 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11157 >  (exit $ac_status); }; } &&
11158 >         { ac_try='test -s conftest.$ac_objext'
11159 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11160 >  (eval $ac_try) 2>&5
11161 >  ac_status=$?
11162 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11163 >  (exit $ac_status); }; }; then
11164 >  ac_cv_cxx_have_std_iostream=yes
11165 > else
11166 >  echo "$as_me: failed program was:" >&5
11167 > sed 's/^/| /' conftest.$ac_ext >&5
11168 >
11169 > fi
11170 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11171 >        cat >conftest.$ac_ext <<_ACEOF
11172 > /* confdefs.h.  */
11173 > _ACEOF
11174 > cat confdefs.h >>conftest.$ac_ext
11175 > cat >>conftest.$ac_ext <<_ACEOF
11176 > /* end confdefs.h.  */
11177 >
11178 > #define __USE_STD_IOSTREAM 1
11179 > #ifdef HAVE_IOSTREAM
11180 > #include <iostream>
11181 > #else
11182 > #include <iostream.h>
11183 > #endif
11184 >
11185 > #ifdef FC_DUMMY_MAIN
11186 > #ifndef FC_DUMMY_MAIN_EQ_F77
11187 > #  ifdef __cplusplus
11188 >     extern "C"
11189 > #  endif
11190 >   int FC_DUMMY_MAIN() { return 1; }
11191 > #endif
11192 > #endif
11193 > int
11194 > main ()
11195 > {
11196 > std::cout<<"Hello World"<<std::endl;return 0;
11197 >  ;
11198 >  return 0;
11199 > }
11200 > _ACEOF
11201 > rm -f conftest.$ac_objext
11202 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11203 >  (eval $ac_compile) 2>conftest.er1
11204 >  ac_status=$?
11205 >  grep -v '^ *+' conftest.er1 >conftest.err
11206 >  rm -f conftest.er1
11207 >  cat conftest.err >&5
11208 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11209 >  (exit $ac_status); } &&
11210 >         { ac_try='test -z "$ac_cxx_werror_flag"
11211 >                         || test ! -s conftest.err'
11212 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11213 >  (eval $ac_try) 2>&5
11214 >  ac_status=$?
11215 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11216 >  (exit $ac_status); }; } &&
11217 >         { ac_try='test -s conftest.$ac_objext'
11218 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11219 >  (eval $ac_try) 2>&5
11220 >  ac_status=$?
11221 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11222 >  (exit $ac_status); }; }; then
11223 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11224 > else
11225 >  echo "$as_me: failed program was:" >&5
11226 > sed 's/^/| /' conftest.$ac_ext >&5
11227 >
11228 > fi
11229 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11230 >        ac_ext=cc
11231 > ac_cpp='$CXXCPP $CPPFLAGS'
11232 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11233 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11234 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11235 >
11236 >      fi
11237 >
11238 > fi
11239 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11240 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11241 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11242 >
11243 > cat >>confdefs.h <<\_ACEOF
11244 > #define HAVE_STD_IOSTREAM 1
11245 > _ACEOF
11246 >
11247 >  fi
11248 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11249 >
11250 > cat >>confdefs.h <<\_ACEOF
11251 > #define __USE_STD_IOSTREAM 1
11252 > _ACEOF
11253 >
11254 >  fi
11255 >
11256 >
11257 >
11258 >
11259 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11260 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11261 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11262 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11263 > else
11264 >
11265 >      ac_cv_cxx_have_std_stl=no
11266 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11267 >
11268 >
11269 >        ac_ext=cc
11270 > ac_cpp='$CXXCPP $CPPFLAGS'
11271 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11272 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11273 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11274 >
11275 >        cat >conftest.$ac_ext <<_ACEOF
11276 > /* confdefs.h.  */
11277 > _ACEOF
11278 > cat confdefs.h >>conftest.$ac_ext
11279 > cat >>conftest.$ac_ext <<_ACEOF
11280 > /* end confdefs.h.  */
11281 > #include <list>
11282 >
11283 > #ifdef FC_DUMMY_MAIN
11284 > #ifndef FC_DUMMY_MAIN_EQ_F77
11285 > #  ifdef __cplusplus
11286 >     extern "C"
11287 > #  endif
11288 >   int FC_DUMMY_MAIN() { return 1; }
11289 > #endif
11290 > #endif
11291 > int
11292 > main ()
11293 > {
11294 > std::list<int> foo;return 0;
11295 >  ;
11296 >  return 0;
11297 > }
11298 > _ACEOF
11299 > rm -f conftest.$ac_objext
11300 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11301 >  (eval $ac_compile) 2>conftest.er1
11302 >  ac_status=$?
11303 >  grep -v '^ *+' conftest.er1 >conftest.err
11304 >  rm -f conftest.er1
11305 >  cat conftest.err >&5
11306 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11307 >  (exit $ac_status); } &&
11308 >         { ac_try='test -z "$ac_cxx_werror_flag"
11309 >                         || test ! -s conftest.err'
11310 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11311 >  (eval $ac_try) 2>&5
11312 >  ac_status=$?
11313 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11314 >  (exit $ac_status); }; } &&
11315 >         { ac_try='test -s conftest.$ac_objext'
11316 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11317 >  (eval $ac_try) 2>&5
11318 >  ac_status=$?
11319 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11320 >  (exit $ac_status); }; }; then
11321 >  ac_cv_cxx_have_std_stl=yes
11322 > else
11323 >  echo "$as_me: failed program was:" >&5
11324 > sed 's/^/| /' conftest.$ac_ext >&5
11325 >
11326 > fi
11327 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11328 >        ac_ext=cc
11329 > ac_cpp='$CXXCPP $CPPFLAGS'
11330 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11331 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11332 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11333 >
11334 >      fi
11335 >
11336 > fi
11337 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11338 > echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11339 >  if test "$ac_cv_cxx_have_std_stl" = yes; then
11340 >
11341 > cat >>confdefs.h <<\_ACEOF
11342 > #define HAVE_STD_STL 1
11343 > _ACEOF
11344 >
11345 >  fi
11346 >
11347 >
11348 >
11349 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11350 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11351 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11352 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11353 > else
11354 >
11355 >    ac_cv_cxx_have_fstream_attach=no
11356 >
11357 >
11358 >    ac_ext=cc
11359 > ac_cpp='$CXXCPP $CPPFLAGS'
11360 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11361 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11362 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11363 >
11364 >    cat >conftest.$ac_ext <<_ACEOF
11365 > /* confdefs.h.  */
11366 > _ACEOF
11367 > cat confdefs.h >>conftest.$ac_ext
11368 > cat >>conftest.$ac_ext <<_ACEOF
11369 > /* end confdefs.h.  */
11370 >
11371 > #ifdef HAVE_IOSTREAM
11372 > #include <fstream>
11373 > #else
11374 > #include <fstream.h>
11375 > #endif
11376 > #ifdef HAVE_STD_IOSTREAM
11377 > using namespace std;
11378 > #endif
11379 >
11380 > #ifdef FC_DUMMY_MAIN
11381 > #ifndef FC_DUMMY_MAIN_EQ_F77
11382 > #  ifdef __cplusplus
11383 >     extern "C"
11384 > #  endif
11385 >   int FC_DUMMY_MAIN() { return 1; }
11386 > #endif
11387 > #endif
11388 > int
11389 > main ()
11390 > {
11391 > int fd=0;ofstream s;s.attach(fd);
11392 >  ;
11393 >  return 0;
11394 > }
11395 > _ACEOF
11396 > rm -f conftest.$ac_objext
11397 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11398 >  (eval $ac_compile) 2>conftest.er1
11399 >  ac_status=$?
11400 >  grep -v '^ *+' conftest.er1 >conftest.err
11401 >  rm -f conftest.er1
11402 >  cat conftest.err >&5
11403 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11404 >  (exit $ac_status); } &&
11405 >         { ac_try='test -z "$ac_cxx_werror_flag"
11406 >                         || test ! -s conftest.err'
11407 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11408 >  (eval $ac_try) 2>&5
11409 >  ac_status=$?
11410 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11411 >  (exit $ac_status); }; } &&
11412 >         { ac_try='test -s conftest.$ac_objext'
11413 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11414 >  (eval $ac_try) 2>&5
11415 >  ac_status=$?
11416 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11417 >  (exit $ac_status); }; }; then
11418 >  ac_cv_cxx_have_fstream_attach=yes
11419 > else
11420 >  echo "$as_me: failed program was:" >&5
11421 > sed 's/^/| /' conftest.$ac_ext >&5
11422 >
11423 > fi
11424 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11425 >    ac_ext=cc
11426 > ac_cpp='$CXXCPP $CPPFLAGS'
11427 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11428 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11429 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11430 >
11431 >
11432 > fi
11433 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11434 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11435 >  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11436 >
11437 > cat >>confdefs.h <<\_ACEOF
11438 > #define HAVE_FSTREAM_ATTACH 1
11439 > _ACEOF
11440 >
11441 >  fi
11442 >
11443 >
11444 >
11445 >  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11446 > echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11447 > if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11448 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11449 > else
11450 >
11451 >    ac_cv_cxx_have_fstream_open=no
11452 >    ac_cv_cxx_fstream_open_prot=no
11453 >
11454 >
11455 >    ac_ext=cc
11456 > ac_cpp='$CXXCPP $CPPFLAGS'
11457 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11458 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11459 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11460 >
11461 >    # Try with 2 parameters
11462 >    cat >conftest.$ac_ext <<_ACEOF
11463 > /* confdefs.h.  */
11464 > _ACEOF
11465 > cat confdefs.h >>conftest.$ac_ext
11466 > cat >>conftest.$ac_ext <<_ACEOF
11467 > /* end confdefs.h.  */
11468 >
11469 > #ifdef HAVE_IOSTREAM
11470 > #include <fstream>
11471 > #else
11472 > #include <fstream.h>
11473 > #endif
11474 > #ifdef HAVE_STD_IOSTREAM
11475 > using namespace std;
11476 > #endif
11477 >
11478 > #ifdef FC_DUMMY_MAIN
11479 > #ifndef FC_DUMMY_MAIN_EQ_F77
11480 > #  ifdef __cplusplus
11481 >     extern "C"
11482 > #  endif
11483 >   int FC_DUMMY_MAIN() { return 1; }
11484 > #endif
11485 > #endif
11486 > int
11487 > main ()
11488 > {
11489 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11490 >  ;
11491 >  return 0;
11492 > }
11493 > _ACEOF
11494 > rm -f conftest.$ac_objext
11495 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11496 >  (eval $ac_compile) 2>conftest.er1
11497 >  ac_status=$?
11498 >  grep -v '^ *+' conftest.er1 >conftest.err
11499 >  rm -f conftest.er1
11500 >  cat conftest.err >&5
11501 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11502 >  (exit $ac_status); } &&
11503 >         { ac_try='test -z "$ac_cxx_werror_flag"
11504 >                         || test ! -s conftest.err'
11505 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11506 >  (eval $ac_try) 2>&5
11507 >  ac_status=$?
11508 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11509 >  (exit $ac_status); }; } &&
11510 >         { ac_try='test -s conftest.$ac_objext'
11511 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11512 >  (eval $ac_try) 2>&5
11513 >  ac_status=$?
11514 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11515 >  (exit $ac_status); }; }; then
11516 >  ac_cv_cxx_have_fstream_open=yes
11517 > else
11518 >  echo "$as_me: failed program was:" >&5
11519 > sed 's/^/| /' conftest.$ac_ext >&5
11520 >
11521 > fi
11522 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11523 >    # Try with mode parameter
11524 >    cat >conftest.$ac_ext <<_ACEOF
11525 > /* confdefs.h.  */
11526 > _ACEOF
11527 > cat confdefs.h >>conftest.$ac_ext
11528 > cat >>conftest.$ac_ext <<_ACEOF
11529 > /* end confdefs.h.  */
11530 >
11531 > #ifdef HAVE_IOSTREAM
11532 > #include <fstream>
11533 > #else
11534 > #include <fstream.h>
11535 > #endif
11536 > #ifdef HAVE_STD_IOSTREAM
11537 > using namespace std;
11538 > #endif
11539 >
11540 > #ifdef FC_DUMMY_MAIN
11541 > #ifndef FC_DUMMY_MAIN_EQ_F77
11542 > #  ifdef __cplusplus
11543 >     extern "C"
11544 > #  endif
11545 >   int FC_DUMMY_MAIN() { return 1; }
11546 > #endif
11547 > #endif
11548 > int
11549 > main ()
11550 > {
11551 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11552 >  ;
11553 >  return 0;
11554 > }
11555 > _ACEOF
11556 > rm -f conftest.$ac_objext
11557 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11558 >  (eval $ac_compile) 2>conftest.er1
11559 >  ac_status=$?
11560 >  grep -v '^ *+' conftest.er1 >conftest.err
11561 >  rm -f conftest.er1
11562 >  cat conftest.err >&5
11563 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11564 >  (exit $ac_status); } &&
11565 >         { ac_try='test -z "$ac_cxx_werror_flag"
11566 >                         || test ! -s conftest.err'
11567 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11568 >  (eval $ac_try) 2>&5
11569 >  ac_status=$?
11570 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11571 >  (exit $ac_status); }; } &&
11572 >         { ac_try='test -s conftest.$ac_objext'
11573 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11574 >  (eval $ac_try) 2>&5
11575 >  ac_status=$?
11576 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11577 >  (exit $ac_status); }; }; then
11578 >  ac_cv_cxx_fstream_open_prot=yes
11579 > else
11580 >  echo "$as_me: failed program was:" >&5
11581 > sed 's/^/| /' conftest.$ac_ext >&5
11582 >
11583 > fi
11584 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11585 >    ac_ext=cc
11586 > ac_cpp='$CXXCPP $CPPFLAGS'
11587 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11588 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11589 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11590 >
11591 >
11592 > fi
11593 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11594 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11595 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11596 >
11597 > cat >>confdefs.h <<\_ACEOF
11598 > #define HAVE_FSTREAM_OPEN 1
11599 > _ACEOF
11600 >
11601 >  fi
11602 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11603 >
11604 > cat >>confdefs.h <<\_ACEOF
11605 > #define FSTREAM_OPEN_PROT 1
11606 > _ACEOF
11607 >
11608 >  fi
11609 >
11610 >
11611 >
11612 >
11613 >
11614 >
11615 >
11616 > for ac_header in ctype.h iostream fstream sstream strstream
11617 > do
11618 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11619 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11620 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
11621 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11622 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11623 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11624 > fi
11625 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11626 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11627 > else
11628 >  # Is the header compilable?
11629 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
11630 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
11631 > cat >conftest.$ac_ext <<_ACEOF
11632 > /* confdefs.h.  */
11633 > _ACEOF
11634 > cat confdefs.h >>conftest.$ac_ext
11635 > cat >>conftest.$ac_ext <<_ACEOF
11636 > /* end confdefs.h.  */
11637 > $ac_includes_default
11638 > #include <$ac_header>
11639 > _ACEOF
11640 > rm -f conftest.$ac_objext
11641 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11642 >  (eval $ac_compile) 2>conftest.er1
11643 >  ac_status=$?
11644 >  grep -v '^ *+' conftest.er1 >conftest.err
11645 >  rm -f conftest.er1
11646 >  cat conftest.err >&5
11647 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11648 >  (exit $ac_status); } &&
11649 >         { ac_try='test -z "$ac_cxx_werror_flag"
11650 >                         || test ! -s conftest.err'
11651 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11652 >  (eval $ac_try) 2>&5
11653 >  ac_status=$?
11654 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11655 >  (exit $ac_status); }; } &&
11656 >         { ac_try='test -s conftest.$ac_objext'
11657 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11658 >  (eval $ac_try) 2>&5
11659 >  ac_status=$?
11660 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11661 >  (exit $ac_status); }; }; then
11662 >  ac_header_compiler=yes
11663 > else
11664 >  echo "$as_me: failed program was:" >&5
11665 > sed 's/^/| /' conftest.$ac_ext >&5
11666 >
11667 > ac_header_compiler=no
11668 > fi
11669 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11670 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11671 > echo "${ECHO_T}$ac_header_compiler" >&6
11672 >
11673 > # Is the header present?
11674 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
11675 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
11676 > cat >conftest.$ac_ext <<_ACEOF
11677 > /* confdefs.h.  */
11678 > _ACEOF
11679 > cat confdefs.h >>conftest.$ac_ext
11680 > cat >>conftest.$ac_ext <<_ACEOF
11681 > /* end confdefs.h.  */
11682 > #include <$ac_header>
11683 > _ACEOF
11684 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
11685 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
11686 >  ac_status=$?
11687 >  grep -v '^ *+' conftest.er1 >conftest.err
11688 >  rm -f conftest.er1
11689 >  cat conftest.err >&5
11690 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11691 >  (exit $ac_status); } >/dev/null; then
11692 >  if test -s conftest.err; then
11693 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11694 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11695 >  else
11696 >    ac_cpp_err=
11697 >  fi
11698 > else
11699 >  ac_cpp_err=yes
11700 > fi
11701 > if test -z "$ac_cpp_err"; then
11702 >  ac_header_preproc=yes
11703 > else
11704 >  echo "$as_me: failed program was:" >&5
11705 > sed 's/^/| /' conftest.$ac_ext >&5
11706 >
11707 >  ac_header_preproc=no
11708 > fi
11709 > rm -f conftest.err conftest.$ac_ext
11710 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11711 > echo "${ECHO_T}$ac_header_preproc" >&6
11712 >
11713 > # So?  What about this header?
11714 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11715 >  yes:no: )
11716 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11717 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11718 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11719 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11720 >    ac_header_preproc=yes
11721 >    ;;
11722 >  no:yes:* )
11723 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11724 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11725 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11726 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11727 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11728 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11729 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11730 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11731 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11732 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11733 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11734 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11735 >    (
11736 >      cat <<\_ASBOX
11737 > ## ------------------------------ ##
11738 > ## Report this to gezelter@nd.edu ##
11739 > ## ------------------------------ ##
11740 > _ASBOX
11741 >    ) |
11742 >      sed "s/^/$as_me: WARNING:     /" >&2
11743 >    ;;
11744 > esac
11745 > echo "$as_me:$LINENO: checking for $ac_header" >&5
11746 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
11747 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
11748 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11749 > else
11750 >  eval "$as_ac_Header=\$ac_header_preproc"
11751 > fi
11752 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
11753 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
11754 >
11755 > fi
11756 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
11757 >  cat >>confdefs.h <<_ACEOF
11758 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11759 > _ACEOF
11760 >
11761 > fi
11762 >
11763 > done
11764 >
11765 > # AC_CPP_FUNC
11766 > # ------------------ #
11767 > # Checks to see if ANSI C99 CPP variable __func__ works.
11768 > # If not, perhaps __FUNCTION__ works instead.
11769 > # If not, we'll just define __func__ to "".
11770 > # AC_CPP_FUNC
11771 >
11772 >
11773 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11774 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11775 > if test "${ac_cv_cpp_func+set}" = set; then
11776 >  echo $ECHO_N "(cached) $ECHO_C" >&6
11777 > else
11778 >  cat >conftest.$ac_ext <<_ACEOF
11779 > /* confdefs.h.  */
11780 > _ACEOF
11781 > cat confdefs.h >>conftest.$ac_ext
11782 > cat >>conftest.$ac_ext <<_ACEOF
11783 > /* end confdefs.h.  */
11784  
11785 < /* Override any gcc2 internal prototype to avoid an error.  */
11786 < #ifdef __cplusplus
11787 < extern "C"
11788 < {
11785 > #ifdef FC_DUMMY_MAIN
11786 > #ifndef FC_DUMMY_MAIN_EQ_F77
11787 > #  ifdef __cplusplus
11788 >     extern "C"
11789 > #  endif
11790 >   int FC_DUMMY_MAIN() { return 1; }
11791   #endif
4894 /* We use char because int might match the return type of a gcc2
4895   builtin and then its argument prototype would still apply.  */
4896 char $ac_func ();
4897 /* The GNU C library defines this for functions which it implements
4898    to always fail with ENOSYS.  Some functions are actually named
4899    something starting with __ and the normal name is an alias.  */
4900 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
4901 choke me
4902 #else
4903 char (*f) () = $ac_func;
11792   #endif
4905 #ifdef __cplusplus
4906 }
4907 #endif
4908
11793   int
11794   main ()
11795   {
11796 < return f != $ac_func;
11796 > const char *foo = __func__;
11797    ;
11798    return 0;
11799   }
11800   _ACEOF
11801 < rm -f conftest.$ac_objext conftest$ac_exeext
11802 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11803 <  (eval $ac_link) 2>conftest.er1
11801 > rm -f conftest.$ac_objext
11802 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11803 >  (eval $ac_compile) 2>conftest.er1
11804    ac_status=$?
11805    grep -v '^ *+' conftest.er1 >conftest.err
11806    rm -f conftest.er1
11807    cat conftest.err >&5
11808    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11809    (exit $ac_status); } &&
11810 <         { ac_try='test -z "$ac_c_werror_flag"
11810 >         { ac_try='test -z "$ac_cxx_werror_flag"
11811                           || test ! -s conftest.err'
11812    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11813    (eval $ac_try) 2>&5
11814    ac_status=$?
11815    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11816    (exit $ac_status); }; } &&
11817 <         { ac_try='test -s conftest$ac_exeext'
11817 >         { ac_try='test -s conftest.$ac_objext'
11818    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11819    (eval $ac_try) 2>&5
11820    ac_status=$?
11821    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11822    (exit $ac_status); }; }; then
11823 <  eval "$as_ac_var=yes"
11823 >  ac_cv_cpp_func=yes
11824   else
11825    echo "$as_me: failed program was:" >&5
11826   sed 's/^/| /' conftest.$ac_ext >&5
11827  
4944 eval "$as_ac_var=no"
4945 fi
4946 rm -f conftest.err conftest.$ac_objext \
4947      conftest$ac_exeext conftest.$ac_ext
4948 fi
4949 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
4950 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
4951 if test `eval echo '${'$as_ac_var'}'` = yes; then
4952  cat >>confdefs.h <<_ACEOF
4953 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
4954 _ACEOF
4955
4956 else
4957  # FreeBSD has a gnugetopt library for this
4958    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
4959 echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
4960 if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
4961  echo $ECHO_N "(cached) $ECHO_C" >&6
4962 else
4963  ac_check_lib_save_LIBS=$LIBS
4964 LIBS="-lgnugetopt  $LIBS"
11828   cat >conftest.$ac_ext <<_ACEOF
11829   /* confdefs.h.  */
11830   _ACEOF
# Line 4969 | Line 11832 | cat >>conftest.$ac_ext <<_ACEOF
11832   cat >>conftest.$ac_ext <<_ACEOF
11833   /* end confdefs.h.  */
11834  
11835 < /* Override any gcc2 internal prototype to avoid an error.  */
11836 < #ifdef __cplusplus
11837 < extern "C"
11835 > #ifdef FC_DUMMY_MAIN
11836 > #ifndef FC_DUMMY_MAIN_EQ_F77
11837 > #  ifdef __cplusplus
11838 >     extern "C"
11839 > #  endif
11840 >   int FC_DUMMY_MAIN() { return 1; }
11841   #endif
11842 < /* We use char because int might match the return type of a gcc2
4977 <   builtin and then its argument prototype would still apply.  */
4978 < char getopt_long ();
11842 > #endif
11843   int
11844   main ()
11845   {
11846 < getopt_long ();
11846 > const char *foo = __FUNCTION__;
11847    ;
11848    return 0;
11849   }
11850   _ACEOF
11851 < rm -f conftest.$ac_objext conftest$ac_exeext
11852 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11853 <  (eval $ac_link) 2>conftest.er1
11851 > rm -f conftest.$ac_objext
11852 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11853 >  (eval $ac_compile) 2>conftest.er1
11854    ac_status=$?
11855    grep -v '^ *+' conftest.er1 >conftest.err
11856    rm -f conftest.er1
11857    cat conftest.err >&5
11858    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11859    (exit $ac_status); } &&
11860 <         { ac_try='test -z "$ac_c_werror_flag"
11860 >         { ac_try='test -z "$ac_cxx_werror_flag"
11861                           || test ! -s conftest.err'
11862    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11863    (eval $ac_try) 2>&5
11864    ac_status=$?
11865    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11866    (exit $ac_status); }; } &&
11867 <         { ac_try='test -s conftest$ac_exeext'
11867 >         { ac_try='test -s conftest.$ac_objext'
11868    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11869    (eval $ac_try) 2>&5
11870    ac_status=$?
11871    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11872    (exit $ac_status); }; }; then
11873 <  ac_cv_lib_gnugetopt_getopt_long=yes
11873 >  ac_cv_cpp_func=__FUNCTION__
11874   else
11875    echo "$as_me: failed program was:" >&5
11876   sed 's/^/| /' conftest.$ac_ext >&5
11877  
11878 < ac_cv_lib_gnugetopt_getopt_long=no
11878 > ac_cv_cpp_func=no
11879   fi
11880 < rm -f conftest.err conftest.$ac_objext \
5017 <      conftest$ac_exeext conftest.$ac_ext
5018 < LIBS=$ac_check_lib_save_LIBS
11880 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11881   fi
11882 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
11883 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
11884 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
11885 <  cat >>confdefs.h <<\_ACEOF
11886 < #define HAVE_GETOPT_LONG 1
11882 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11883 > fi
11884 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11885 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
11886 > if test $ac_cv_cpp_func = __FUNCTION__; then
11887 >
11888 > cat >>confdefs.h <<\_ACEOF
11889 > #define __func__ __FUNCTION__
11890   _ACEOF
11891  
11892 < else
5028 <  # use the GNU replacement
5029 <      case $LIBOBJS in
5030 <    "getopt.$ac_objext"   | \
5031 <  *" getopt.$ac_objext"   | \
5032 <    "getopt.$ac_objext "* | \
5033 <  *" getopt.$ac_objext "* ) ;;
5034 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
5035 < esac
11892 > elif test $ac_cv_cpp_func = no; then
11893  
11894 <      case $LIBOBJS in
11895 <    "getopt1.$ac_objext"   | \
11896 <  *" getopt1.$ac_objext"   | \
5040 <    "getopt1.$ac_objext "* | \
5041 <  *" getopt1.$ac_objext "* ) ;;
5042 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
5043 < esac
5044 <
5045 <                ac_config_links="$ac_config_links utils/getopt.h:utils/gnugetopt.h"
11894 > cat >>confdefs.h <<\_ACEOF
11895 > #define __func__ ""
11896 > _ACEOF
11897  
11898   fi
11899  
5049 fi
5050 done
11900  
11901  
11902  
11903 +
11904   case $debug in
11905    1)
11906       ;;
# Line 5059 | Line 11909 | case $debug in
11909  
11910  
11911  
11912 + # Try to determine "good" native compiler flags if none specified on command
11913 + # line
11914  
11915 + if test "$ac_test_FFLAGS" != "set"; then
11916 +  FCFLAGS=""
11917 +  case "${host_cpu}-${host_os}" in
11918  
11919 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11920 +                    FCFLAGS="-O3 -ip -no-prec-div -cxxlib-icc"
11921 +                fi;;
11922 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11923 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11924 +                fi;;
11925 +   powerpc*-aix*)
11926 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11927 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11928 +                echo "*******************************************************"
11929 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
11930 +                echo "*  recommended that you use                           *"
11931 +                echo "*                                                     *"
11932 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
11933 +                echo "*                                 ^^^                 *"
11934 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
11935 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
11936 +                echo "*******************************************************"
11937 +        fi;;
11938 +   *darwin*)
11939 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11940 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
11941 +        fi
11942 +        if test "$FC" = ifort; then
11943 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
11944 +        fi;;
11945 +  esac
11946 +
11947 +  if test -n "$CPU_FLAGS"; then
11948 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
11949 +  fi
11950 +
11951 +  if test -z "$FCFLAGS"; then
11952 +        echo ""
11953 +        echo "*********************************************************"
11954 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
11955 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11956 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
11957 +        echo "*********************************************************"
11958 +        echo ""
11959 +        FCFLAGS="-O3"
11960 +  fi
11961 +
11962 +
11963 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
11964 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
11965 + if test "${ac_guessed_f90flags+set}" = set; then
11966 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11967 + else
11968 +
11969 +
11970 +
11971 + ac_ext=${FC_SRCEXT-f}
11972 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
11973 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
11974 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
11975 +
11976 + echo 'program main' > conftest.$ac_ext
11977 + echo 'end program main' >> conftest.$ac_ext
11978 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
11979 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11980 +  (eval $ac_compile) 2>&5
11981 +  ac_status=$?
11982 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11983 +  (exit $ac_status); }; then
11984 +        ac_guessed_f90flags=yes
11985 + else
11986 +        ac_guessed_f90flags=no
11987 + fi
11988 + rm -f conftest*
11989 + ac_ext=cc
11990 + ac_cpp='$CXXCPP $CPPFLAGS'
11991 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11992 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11993 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11994 +
11995 +
11996 + fi
11997 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
11998 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
11999 + if test "$ac_guessed_f90flags" = yes; then
12000 +        :
12001 +
12002 + else
12003 +        :
12004 +
12005 +        echo ""
12006 +        echo "**********************************************************"
12007 +        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12008 +        echo "* your compiler.                                        *"
12009 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12010 +        echo "*********************************************************"
12011 +        echo ""
12012 +        FCFLAGS=""
12013 +
12014 + fi
12015 +
12016 +
12017 + fi
12018 +
12019 +
12020 +
12021 +
12022 +
12023 +
12024 +
12025   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12026   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12027   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 5069 | Line 12030 | cat > conftest.c <<EOF
12030  
12031   cat > conftest.c <<EOF
12032   #ifdef __GNUC__
12033 <  #ifndef __INTEL_COMPILER
12033 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12034 >     no;
12035 >  #else
12036       yes;
12037    #endif
12038   #endif
# Line 5107 | Line 12070 | if test "$ac_test_CFLAGS" != "set"; then
12070                      CFLAGS="-O"
12071                  fi;;
12072    sparc-solaris2*) if test "$CC" = cc; then
12073 <                    CFLAGS="-native -fast -xO5 -dalign"
12073 >                    CFLAGS="-O -dalign"
12074                   fi;;
12075  
12076    alpha*-osf*)  if test "$CC" = cc; then
# Line 5136 | Line 12099 | if test "$ac_test_CFLAGS" != "set"; then
12099          fi;;
12100     *darwin*)
12101          if test "$CC" = xlc -o "$CC" = cc; then
12102 <                CFLAGS="-qthreaded -O5 -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12102 >                CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12103 >        fi
12104 >        if test "$CC" = icc; then
12105 >                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12106          fi;;
12107    esac
12108  
# Line 5150 | Line 12116 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12116      # -malign-double for x86 systems
12117  
12118  
12119 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12120 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12119 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12120 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12121   if test "${ac_align_double+set}" = set; then
12122    echo $ECHO_N "(cached) $ECHO_C" >&6
12123   else
12124    echo 'void f(){}' > conftest.c
12125 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12125 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12126          ac_align_double=yes
12127   else
12128          ac_align_double=no
# Line 5177 | Line 12143 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12143      # -fstrict-aliasing for gcc-2.95+
12144  
12145  
12146 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12147 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12146 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12147 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12148   if test "${ac_fstrict_aliasing+set}" = set; then
12149    echo $ECHO_N "(cached) $ECHO_C" >&6
12150   else
12151    echo 'void f(){}' > conftest.c
12152 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12152 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12153          ac_fstrict_aliasing=yes
12154   else
12155          ac_fstrict_aliasing=no
# Line 5208 | Line 12174 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12174                    case "${host_cpu}" in
12175            i586*)
12176  
12177 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12178 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12177 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12178 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12179   if test "${ac_cpu_pentium+set}" = set; then
12180    echo $ECHO_N "(cached) $ECHO_C" >&6
12181   else
12182    echo 'void f(){}' > conftest.c
12183 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12183 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12184          ac_cpu_pentium=yes
12185   else
12186          ac_cpu_pentium=no
# Line 5231 | Line 12197 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12197          :
12198  
12199  
12200 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12201 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12200 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12201 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12202   if test "${ac_pentium+set}" = set; then
12203    echo $ECHO_N "(cached) $ECHO_C" >&6
12204   else
12205    echo 'void f(){}' > conftest.c
12206 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12206 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12207          ac_pentium=yes
12208   else
12209          ac_pentium=no
# Line 5260 | Line 12226 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12226                    ;;
12227            i686*)
12228  
12229 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12230 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12229 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12230 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12231   if test "${ac_cpu_pentiumpro+set}" = set; then
12232    echo $ECHO_N "(cached) $ECHO_C" >&6
12233   else
12234    echo 'void f(){}' > conftest.c
12235 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12235 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12236          ac_cpu_pentiumpro=yes
12237   else
12238          ac_cpu_pentiumpro=no
# Line 5283 | Line 12249 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12249          :
12250  
12251  
12252 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12253 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12252 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12253 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12254   if test "${ac_pentiumpro+set}" = set; then
12255    echo $ECHO_N "(cached) $ECHO_C" >&6
12256   else
12257    echo 'void f(){}' > conftest.c
12258 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12258 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12259          ac_pentiumpro=yes
12260   else
12261          ac_pentiumpro=no
# Line 5316 | Line 12282 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12282                  if test -n "$is60x"; then
12283  
12284  
12285 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12286 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12285 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12286 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12287   if test "${ac_m_cpu_60x+set}" = set; then
12288    echo $ECHO_N "(cached) $ECHO_C" >&6
12289   else
12290    echo 'void f(){}' > conftest.c
12291 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12291 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12292          ac_m_cpu_60x=yes
12293   else
12294          ac_m_cpu_60x=no
# Line 5374 | Line 12340 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12340          :
12341  
12342  
12343 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12344 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12343 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12344 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12345   if test "${ac_m_cpu_750+set}" = set; then
12346    echo $ECHO_N "(cached) $ECHO_C" >&6
12347   else
12348    echo 'void f(){}' > conftest.c
12349 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12349 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12350          ac_m_cpu_750=yes
12351   else
12352          ac_m_cpu_750=no
# Line 5407 | Line 12373 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12373                  if test -z "$CPU_FLAGS"; then
12374  
12375  
12376 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12377 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12376 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12377 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12378   if test "${ac_m_cpu_powerpc+set}" = set; then
12379    echo $ECHO_N "(cached) $ECHO_C" >&6
12380   else
12381    echo 'void f(){}' > conftest.c
12382 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12382 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12383          ac_m_cpu_powerpc=yes
12384   else
12385          ac_m_cpu_powerpc=no
# Line 5435 | Line 12401 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12401                  if test -z "$CPU_FLAGS"; then
12402  
12403  
12404 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12405 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12404 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12405 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12406   if test "${ac_m_powerpc+set}" = set; then
12407    echo $ECHO_N "(cached) $ECHO_C" >&6
12408   else
12409    echo 'void f(){}' > conftest.c
12410 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12410 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12411          ac_m_powerpc=yes
12412   else
12413          ac_m_powerpc=no
# Line 5480 | Line 12446 | echo "$as_me:$LINENO: checking whether ${CC-cc} accept
12446  
12447  
12448  
12449 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12450 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12449 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12450 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12451   if test "${ac_guessed_cflags+set}" = set; then
12452    echo $ECHO_N "(cached) $ECHO_C" >&6
12453   else
12454    echo 'void f(){}' > conftest.c
12455 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12455 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12456          ac_guessed_cflags=yes
12457   else
12458          ac_guessed_cflags=no
# Line 5530 | Line 12496 | cat > conftest.cpp <<EOF
12496  
12497   cat > conftest.cpp <<EOF
12498   #ifdef __GNUC__
12499 <  #ifndef __INTEL_COMPILER
12499 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12500 >     no;
12501 >  #else
12502       yes;
12503    #endif
12504   #endif
# Line 5568 | Line 12536 | if test "$ac_test_CXXFLAGS" != "set"; then
12536                      CXXFLAGS="-O"
12537                  fi;;
12538    sparc-solaris2*) if test "$CXX" = CC; then
12539 <                    CXXFLAGS="-native -fast -xO5 -dalign"
12539 >                    CXXFLAGS="-features=extensions -O -dalign"
12540                   fi;;
12541     rs6000*-aix*)  if test "$CXX" = xlC; then
12542                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 5587 | Line 12555 | if test "$ac_test_CXXFLAGS" != "set"; then
12555                  echo "*******************************************************"
12556          fi;;
12557     *darwin*)
12558 <        if test "$CXX" = xlc++; then
12559 <                CXXFLAGS="-qthreaded -O5 -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12558 >        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12559 >                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12560 >        fi
12561 >        if test "$CXX" = icpc; then
12562 >                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12563          fi;;
12564    esac
12565  
# Line 5602 | Line 12573 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12573      # -malign-double for x86 systems
12574  
12575  
12576 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12577 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12576 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12577 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12578   if test "${ac_align_double+set}" = set; then
12579    echo $ECHO_N "(cached) $ECHO_C" >&6
12580   else
12581    echo 'void f(){}' > conftest.cpp
12582 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12582 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12583          ac_align_double=yes
12584   else
12585          ac_align_double=no
# Line 5629 | Line 12600 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12600      # -fstrict-aliasing for gcc-2.95+
12601  
12602  
12603 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12604 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12603 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12604 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12605   if test "${ac_fstrict_aliasing+set}" = set; then
12606    echo $ECHO_N "(cached) $ECHO_C" >&6
12607   else
12608    echo 'void f(){}' > conftest.cpp
12609 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12609 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12610          ac_fstrict_aliasing=yes
12611   else
12612          ac_fstrict_aliasing=no
# Line 5660 | Line 12631 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12631                    case "${host_cpu}" in
12632            i586*)
12633  
12634 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12635 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12634 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12635 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12636   if test "${ac_cpu_pentium+set}" = set; then
12637    echo $ECHO_N "(cached) $ECHO_C" >&6
12638   else
12639    echo 'void f(){}' > conftest.cpp
12640 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12640 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12641          ac_cpu_pentium=yes
12642   else
12643          ac_cpu_pentium=no
# Line 5683 | Line 12654 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12654          :
12655  
12656  
12657 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12658 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12657 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12658 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12659   if test "${ac_pentium+set}" = set; then
12660    echo $ECHO_N "(cached) $ECHO_C" >&6
12661   else
12662    echo 'void f(){}' > conftest.cpp
12663 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12663 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12664          ac_pentium=yes
12665   else
12666          ac_pentium=no
# Line 5712 | Line 12683 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12683                    ;;
12684            i686*)
12685  
12686 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
12687 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12686 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
12687 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12688   if test "${ac_cpu_pentiumpro+set}" = set; then
12689    echo $ECHO_N "(cached) $ECHO_C" >&6
12690   else
12691    echo 'void f(){}' > conftest.cpp
12692 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12692 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12693          ac_cpu_pentiumpro=yes
12694   else
12695          ac_cpu_pentiumpro=no
# Line 5735 | Line 12706 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12706          :
12707  
12708  
12709 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
12710 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
12709 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
12710 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
12711   if test "${ac_pentiumpro+set}" = set; then
12712    echo $ECHO_N "(cached) $ECHO_C" >&6
12713   else
12714    echo 'void f(){}' > conftest.cpp
12715 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
12715 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12716          ac_pentiumpro=yes
12717   else
12718          ac_pentiumpro=no
# Line 5768 | Line 12739 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12739                  if test -n "$is60x"; then
12740  
12741  
12742 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
12743 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
12742 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
12743 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
12744   if test "${ac_m_cpu_60x+set}" = set; then
12745    echo $ECHO_N "(cached) $ECHO_C" >&6
12746   else
12747    echo 'void f(){}' > conftest.cpp
12748 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12748 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12749          ac_m_cpu_60x=yes
12750   else
12751          ac_m_cpu_60x=no
# Line 5826 | Line 12797 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12797          :
12798  
12799  
12800 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
12801 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
12800 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12801 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12802   if test "${ac_m_cpu_750+set}" = set; then
12803    echo $ECHO_N "(cached) $ECHO_C" >&6
12804   else
12805    echo 'void f(){}' > conftest.cpp
12806 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
12806 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12807          ac_m_cpu_750=yes
12808   else
12809          ac_m_cpu_750=no
# Line 5859 | Line 12830 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12830                  if test -z "$CPU_FLAGS"; then
12831  
12832  
12833 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
12834 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
12833 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12834 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12835   if test "${ac_m_cpu_powerpc+set}" = set; then
12836    echo $ECHO_N "(cached) $ECHO_C" >&6
12837   else
12838    echo 'void f(){}' > conftest.cpp
12839 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12839 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12840          ac_m_cpu_powerpc=yes
12841   else
12842          ac_m_cpu_powerpc=no
# Line 5887 | Line 12858 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12858                  if test -z "$CPU_FLAGS"; then
12859  
12860  
12861 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
12862 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
12861 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12862 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12863   if test "${ac_m_powerpc+set}" = set; then
12864    echo $ECHO_N "(cached) $ECHO_C" >&6
12865   else
12866    echo 'void f(){}' > conftest.cpp
12867 < if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
12867 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12868          ac_m_powerpc=yes
12869   else
12870          ac_m_powerpc=no
# Line 5932 | Line 12903 | echo "$as_me:$LINENO: checking whether ${CXX-c++} acce
12903  
12904  
12905  
12906 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
12907 < echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
12906 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12907 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12908   if test "${ac_guessed_cxxflags+set}" = set; then
12909    echo $ECHO_N "(cached) $ECHO_C" >&6
12910   else
12911    echo 'void f(){}' > conftest.cpp
12912 < if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12912 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12913          ac_guessed_cxxflags=yes
12914   else
12915          ac_guessed_cxxflags=no
# Line 5962 | Line 12933 | else
12933          echo "**********************************************************"
12934          echo ""
12935          CXXFLAGS=""
5965
5966 fi
5967
5968
5969 fi
5970
5971
5972
5973
5974
5975 # Try to determine "good" native compiler flags if none specified on command
5976 # line
5977
5978 if test x"$F90FLAGS" = x ; then
5979  F90FLAGS=""
5980  case "${host_cpu}-${host_os}" in
5981
5982  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
5983                    F90FLAGS="-O"
5984                fi;;
5985   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
5986                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
5987                fi;;
5988   powerpc*-aix*)
5989        if test "$F90" = f90 -o "$F90" = xlf90; then
5990                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
5991                echo "*******************************************************"
5992                echo "*  You have AIX on an unknown powerpc system.  It is  *"
5993                echo "*  recommended that you use                           *"
5994                echo "*                                                     *"
5995                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
5996                echo "*                                 ^^^                 *"
5997                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
5998                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
5999                echo "*******************************************************"
6000        fi;;
6001   *darwin*)
6002        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
6003                F90FLAGS="-qthreaded -O5 -qtune=auto -qarch=auto -qunroll=auto"
6004        fi;;
6005  esac
6006
6007  if test -n "$CPU_FLAGS"; then
6008        F90FLAGS="$F90FLAGS $CPU_FLAGS"
6009  fi
6010
6011  if test -z "$F90FLAGS"; then
6012        echo ""
6013        echo "**********************************************************"
6014        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
6015        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6016        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
6017        echo "**********************************************************"
6018        echo ""
6019        F90FLAGS="-O3"
6020  fi
6021
6022
6023 echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
6024 echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
6025 if test "${ac_guessed_f90flags+set}" = set; then
6026  echo $ECHO_N "(cached) $ECHO_C" >&6
6027 else
6028
6029
6030
6031 ac_ext=f90
6032 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
6033 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6034 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
6035
6036 echo 'program main' > conftest.$ac_ext
6037 echo 'end program main' >> conftest.$ac_ext
6038 ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
6039 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6040  (eval $ac_compile) 2>&5
6041  ac_status=$?
6042  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6043  (exit $ac_status); }; then
6044        ac_guessed_f90flags=yes
6045 else
6046        ac_guessed_f90flags=no
6047 fi
6048 rm -f conftest*
6049 ac_ext=c
6050 ac_cpp='$CPP $CPPFLAGS'
6051 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6052 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6053 ac_compiler_gnu=$ac_cv_c_compiler_gnu
6054
6055
6056 fi
6057 echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
6058 echo "${ECHO_T}$ac_guessed_f90flags" >&6
6059 if test "$ac_guessed_f90flags" = yes; then
6060        :
6061
6062 else
6063        :
6064
6065        echo ""
6066        echo "**********************************************************"
6067        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
6068        echo "* your compiler.                                         *"
6069        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
6070        echo "**********************************************************"
6071        echo ""
6072        F90FLAGS=""
6073
6074 fi
6075
6076
6077 fi
6078
6079     ;;
6080 esac
6081
6082 # Find a good install program.  We prefer a C program (faster),
6083 # so one script is as good as another.  But avoid the broken or
6084 # incompatible versions:
6085 # SysV /etc/install, /usr/sbin/install
6086 # SunOS /usr/etc/install
6087 # IRIX /sbin/install
6088 # AIX /bin/install
6089 # AmigaOS /C/install, which installs bootblocks on floppy discs
6090 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
6091 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
6092 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
6093 # OS/2's system install, which has a completely different semantic
6094 # ./install, which can be erroneously created by make from ./install.sh.
6095 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
6096 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
6097 if test -z "$INSTALL"; then
6098 if test "${ac_cv_path_install+set}" = set; then
6099  echo $ECHO_N "(cached) $ECHO_C" >&6
6100 else
6101  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6102 for as_dir in $PATH
6103 do
6104  IFS=$as_save_IFS
6105  test -z "$as_dir" && as_dir=.
6106  # Account for people who put trailing slashes in PATH elements.
6107 case $as_dir/ in
6108  ./ | .// | /cC/* | \
6109  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
6110  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
6111  /usr/ucb/* ) ;;
6112  *)
6113    # OSF1 and SCO ODT 3.0 have their own names for install.
6114    # Don't use installbsd from OSF since it installs stuff as root
6115    # by default.
6116    for ac_prog in ginstall scoinst install; do
6117      for ac_exec_ext in '' $ac_executable_extensions; do
6118        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
6119          if test $ac_prog = install &&
6120            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6121            # AIX install.  It has an incompatible calling convention.
6122            :
6123          elif test $ac_prog = install &&
6124            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6125            # program-specific install script used by HP pwplus--don't use.
6126            :
6127          else
6128            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
6129            break 3
6130          fi
6131        fi
6132      done
6133    done
6134    ;;
6135 esac
6136 done
6137
6138
6139 fi
6140  if test "${ac_cv_path_install+set}" = set; then
6141    INSTALL=$ac_cv_path_install
6142  else
6143    # As a last resort, use the slow shell script.  We don't cache a
6144    # path for INSTALL within a source directory, because that will
6145    # break other packages using the cache if that directory is
6146    # removed, or if the path is relative.
6147    INSTALL=$ac_install_sh
6148  fi
6149 fi
6150 echo "$as_me:$LINENO: result: $INSTALL" >&5
6151 echo "${ECHO_T}$INSTALL" >&6
6152
6153 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
6154 # It thinks the first close brace ends the variable substitution.
6155 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
6156
6157 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
6158
6159 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
6160
6161 echo "$as_me:$LINENO: checking whether ln -s works" >&5
6162 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
6163 LN_S=$as_ln_s
6164 if test "$LN_S" = "ln -s"; then
6165  echo "$as_me:$LINENO: result: yes" >&5
6166 echo "${ECHO_T}yes" >&6
6167 else
6168  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
6169 echo "${ECHO_T}no, using $LN_S" >&6
6170 fi
6171
6172 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6173 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
6174 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
6175 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
6176  echo $ECHO_N "(cached) $ECHO_C" >&6
6177 else
6178  cat >conftest.make <<\_ACEOF
6179 all:
6180        @echo 'ac_maketemp="$(MAKE)"'
6181 _ACEOF
6182 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
6183 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
6184 if test -n "$ac_maketemp"; then
6185  eval ac_cv_prog_make_${ac_make}_set=yes
6186 else
6187  eval ac_cv_prog_make_${ac_make}_set=no
6188 fi
6189 rm -f conftest.make
6190 fi
6191 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
6192  echo "$as_me:$LINENO: result: yes" >&5
6193 echo "${ECHO_T}yes" >&6
6194  SET_MAKE=
6195 else
6196  echo "$as_me:$LINENO: result: no" >&5
6197 echo "${ECHO_T}no" >&6
6198  SET_MAKE="MAKE=${MAKE-make}"
6199 fi
6200
6201 if test -n "$ac_tool_prefix"; then
6202  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6203 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6204 echo "$as_me:$LINENO: checking for $ac_word" >&5
6205 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6206 if test "${ac_cv_prog_RANLIB+set}" = set; then
6207  echo $ECHO_N "(cached) $ECHO_C" >&6
6208 else
6209  if test -n "$RANLIB"; then
6210  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
6211 else
6212 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6213 for as_dir in $PATH
6214 do
6215  IFS=$as_save_IFS
6216  test -z "$as_dir" && as_dir=.
6217  for ac_exec_ext in '' $ac_executable_extensions; do
6218  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6219    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6220    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6221    break 2
6222  fi
6223 done
6224 done
6225
6226 fi
6227 fi
6228 RANLIB=$ac_cv_prog_RANLIB
6229 if test -n "$RANLIB"; then
6230  echo "$as_me:$LINENO: result: $RANLIB" >&5
6231 echo "${ECHO_T}$RANLIB" >&6
6232 else
6233  echo "$as_me:$LINENO: result: no" >&5
6234 echo "${ECHO_T}no" >&6
6235 fi
6236
6237 fi
6238 if test -z "$ac_cv_prog_RANLIB"; then
6239  ac_ct_RANLIB=$RANLIB
6240  # Extract the first word of "ranlib", so it can be a program name with args.
6241 set dummy ranlib; ac_word=$2
6242 echo "$as_me:$LINENO: checking for $ac_word" >&5
6243 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6244 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
6245  echo $ECHO_N "(cached) $ECHO_C" >&6
6246 else
6247  if test -n "$ac_ct_RANLIB"; then
6248  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
6249 else
6250 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6251 for as_dir in $PATH
6252 do
6253  IFS=$as_save_IFS
6254  test -z "$as_dir" && as_dir=.
6255  for ac_exec_ext in '' $ac_executable_extensions; do
6256  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6257    ac_cv_prog_ac_ct_RANLIB="ranlib"
6258    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6259    break 2
6260  fi
6261 done
6262 done
6263
6264  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
6265 fi
6266 fi
6267 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6268 if test -n "$ac_ct_RANLIB"; then
6269  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
6270 echo "${ECHO_T}$ac_ct_RANLIB" >&6
6271 else
6272  echo "$as_me:$LINENO: result: no" >&5
6273 echo "${ECHO_T}no" >&6
6274 fi
6275
6276  RANLIB=$ac_ct_RANLIB
6277 else
6278  RANLIB="$ac_cv_prog_RANLIB"
6279 fi
6280
6281 for ac_prog in 'bison -y' byacc
6282 do
6283  # Extract the first word of "$ac_prog", so it can be a program name with args.
6284 set dummy $ac_prog; ac_word=$2
6285 echo "$as_me:$LINENO: checking for $ac_word" >&5
6286 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6287 if test "${ac_cv_prog_YACC+set}" = set; then
6288  echo $ECHO_N "(cached) $ECHO_C" >&6
6289 else
6290  if test -n "$YACC"; then
6291  ac_cv_prog_YACC="$YACC" # Let the user override the test.
6292 else
6293 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6294 for as_dir in $PATH
6295 do
6296  IFS=$as_save_IFS
6297  test -z "$as_dir" && as_dir=.
6298  for ac_exec_ext in '' $ac_executable_extensions; do
6299  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6300    ac_cv_prog_YACC="$ac_prog"
6301    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6302    break 2
6303  fi
6304 done
6305 done
6306
6307 fi
6308 fi
6309 YACC=$ac_cv_prog_YACC
6310 if test -n "$YACC"; then
6311  echo "$as_me:$LINENO: result: $YACC" >&5
6312 echo "${ECHO_T}$YACC" >&6
6313 else
6314  echo "$as_me:$LINENO: result: no" >&5
6315 echo "${ECHO_T}no" >&6
6316 fi
6317
6318  test -n "$YACC" && break
6319 done
6320 test -n "$YACC" || YACC="yacc"
6321
6322 for ac_prog in flex lex
6323 do
6324  # Extract the first word of "$ac_prog", so it can be a program name with args.
6325 set dummy $ac_prog; ac_word=$2
6326 echo "$as_me:$LINENO: checking for $ac_word" >&5
6327 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6328 if test "${ac_cv_prog_LEX+set}" = set; then
6329  echo $ECHO_N "(cached) $ECHO_C" >&6
6330 else
6331  if test -n "$LEX"; then
6332  ac_cv_prog_LEX="$LEX" # Let the user override the test.
6333 else
6334 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6335 for as_dir in $PATH
6336 do
6337  IFS=$as_save_IFS
6338  test -z "$as_dir" && as_dir=.
6339  for ac_exec_ext in '' $ac_executable_extensions; do
6340  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6341    ac_cv_prog_LEX="$ac_prog"
6342    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6343    break 2
6344  fi
6345 done
6346 done
6347
6348 fi
6349 fi
6350 LEX=$ac_cv_prog_LEX
6351 if test -n "$LEX"; then
6352  echo "$as_me:$LINENO: result: $LEX" >&5
6353 echo "${ECHO_T}$LEX" >&6
6354 else
6355  echo "$as_me:$LINENO: result: no" >&5
6356 echo "${ECHO_T}no" >&6
6357 fi
6358
6359  test -n "$LEX" && break
6360 done
6361 test -n "$LEX" || LEX=":"
6362
6363 if test -z "$LEXLIB"
6364 then
6365  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
6366 echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
6367 if test "${ac_cv_lib_fl_yywrap+set}" = set; then
6368  echo $ECHO_N "(cached) $ECHO_C" >&6
6369 else
6370  ac_check_lib_save_LIBS=$LIBS
6371 LIBS="-lfl  $LIBS"
6372 cat >conftest.$ac_ext <<_ACEOF
6373 /* confdefs.h.  */
6374 _ACEOF
6375 cat confdefs.h >>conftest.$ac_ext
6376 cat >>conftest.$ac_ext <<_ACEOF
6377 /* end confdefs.h.  */
6378
6379 /* Override any gcc2 internal prototype to avoid an error.  */
6380 #ifdef __cplusplus
6381 extern "C"
6382 #endif
6383 /* We use char because int might match the return type of a gcc2
6384   builtin and then its argument prototype would still apply.  */
6385 char yywrap ();
6386 int
6387 main ()
6388 {
6389 yywrap ();
6390  ;
6391  return 0;
6392 }
6393 _ACEOF
6394 rm -f conftest.$ac_objext conftest$ac_exeext
6395 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6396  (eval $ac_link) 2>conftest.er1
6397  ac_status=$?
6398  grep -v '^ *+' conftest.er1 >conftest.err
6399  rm -f conftest.er1
6400  cat conftest.err >&5
6401  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6402  (exit $ac_status); } &&
6403         { ac_try='test -z "$ac_c_werror_flag"
6404                         || test ! -s conftest.err'
6405  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6406  (eval $ac_try) 2>&5
6407  ac_status=$?
6408  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6409  (exit $ac_status); }; } &&
6410         { ac_try='test -s conftest$ac_exeext'
6411  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6412  (eval $ac_try) 2>&5
6413  ac_status=$?
6414  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6415  (exit $ac_status); }; }; then
6416  ac_cv_lib_fl_yywrap=yes
6417 else
6418  echo "$as_me: failed program was:" >&5
6419 sed 's/^/| /' conftest.$ac_ext >&5
6420
6421 ac_cv_lib_fl_yywrap=no
6422 fi
6423 rm -f conftest.err conftest.$ac_objext \
6424      conftest$ac_exeext conftest.$ac_ext
6425 LIBS=$ac_check_lib_save_LIBS
6426 fi
6427 echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
6428 echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
6429 if test $ac_cv_lib_fl_yywrap = yes; then
6430  LEXLIB="-lfl"
6431 else
6432  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
6433 echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
6434 if test "${ac_cv_lib_l_yywrap+set}" = set; then
6435  echo $ECHO_N "(cached) $ECHO_C" >&6
6436 else
6437  ac_check_lib_save_LIBS=$LIBS
6438 LIBS="-ll  $LIBS"
6439 cat >conftest.$ac_ext <<_ACEOF
6440 /* confdefs.h.  */
6441 _ACEOF
6442 cat confdefs.h >>conftest.$ac_ext
6443 cat >>conftest.$ac_ext <<_ACEOF
6444 /* end confdefs.h.  */
6445
6446 /* Override any gcc2 internal prototype to avoid an error.  */
6447 #ifdef __cplusplus
6448 extern "C"
6449 #endif
6450 /* We use char because int might match the return type of a gcc2
6451   builtin and then its argument prototype would still apply.  */
6452 char yywrap ();
6453 int
6454 main ()
6455 {
6456 yywrap ();
6457  ;
6458  return 0;
6459 }
6460 _ACEOF
6461 rm -f conftest.$ac_objext conftest$ac_exeext
6462 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6463  (eval $ac_link) 2>conftest.er1
6464  ac_status=$?
6465  grep -v '^ *+' conftest.er1 >conftest.err
6466  rm -f conftest.er1
6467  cat conftest.err >&5
6468  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6469  (exit $ac_status); } &&
6470         { ac_try='test -z "$ac_c_werror_flag"
6471                         || test ! -s conftest.err'
6472  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6473  (eval $ac_try) 2>&5
6474  ac_status=$?
6475  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6476  (exit $ac_status); }; } &&
6477         { ac_try='test -s conftest$ac_exeext'
6478  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6479  (eval $ac_try) 2>&5
6480  ac_status=$?
6481  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6482  (exit $ac_status); }; }; then
6483  ac_cv_lib_l_yywrap=yes
6484 else
6485  echo "$as_me: failed program was:" >&5
6486 sed 's/^/| /' conftest.$ac_ext >&5
6487
6488 ac_cv_lib_l_yywrap=no
6489 fi
6490 rm -f conftest.err conftest.$ac_objext \
6491      conftest$ac_exeext conftest.$ac_ext
6492 LIBS=$ac_check_lib_save_LIBS
6493 fi
6494 echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
6495 echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
6496 if test $ac_cv_lib_l_yywrap = yes; then
6497  LEXLIB="-ll"
6498 fi
6499
6500 fi
6501
6502 fi
6503
6504 if test "x$LEX" != "x:"; then
6505  echo "$as_me:$LINENO: checking lex output file root" >&5
6506 echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
6507 if test "${ac_cv_prog_lex_root+set}" = set; then
6508  echo $ECHO_N "(cached) $ECHO_C" >&6
6509 else
6510  # The minimal lex program is just a single line: %%.  But some broken lexes
6511 # (Solaris, I think it was) want two %% lines, so accommodate them.
6512 cat >conftest.l <<_ACEOF
6513 %%
6514 %%
6515 _ACEOF
6516 { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
6517  (eval $LEX conftest.l) 2>&5
6518  ac_status=$?
6519  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6520  (exit $ac_status); }
6521 if test -f lex.yy.c; then
6522  ac_cv_prog_lex_root=lex.yy
6523 elif test -f lexyy.c; then
6524  ac_cv_prog_lex_root=lexyy
6525 else
6526  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
6527 echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
6528   { (exit 1); exit 1; }; }
6529 fi
6530 fi
6531 echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
6532 echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
6533 rm -f conftest.l
6534 LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
6535
6536 echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
6537 echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
6538 if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
6539  echo $ECHO_N "(cached) $ECHO_C" >&6
6540 else
6541  # POSIX says lex can declare yytext either as a pointer or an array; the
6542 # default is implementation-dependent. Figure out which it is, since
6543 # not all implementations provide the %pointer and %array declarations.
6544 ac_cv_prog_lex_yytext_pointer=no
6545 echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
6546 ac_save_LIBS=$LIBS
6547 LIBS="$LIBS $LEXLIB"
6548 cat >conftest.$ac_ext <<_ACEOF
6549 `cat $LEX_OUTPUT_ROOT.c`
6550 _ACEOF
6551 rm -f conftest.$ac_objext conftest$ac_exeext
6552 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6553  (eval $ac_link) 2>conftest.er1
6554  ac_status=$?
6555  grep -v '^ *+' conftest.er1 >conftest.err
6556  rm -f conftest.er1
6557  cat conftest.err >&5
6558  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6559  (exit $ac_status); } &&
6560         { ac_try='test -z "$ac_c_werror_flag"
6561                         || test ! -s conftest.err'
6562  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6563  (eval $ac_try) 2>&5
6564  ac_status=$?
6565  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6566  (exit $ac_status); }; } &&
6567         { ac_try='test -s conftest$ac_exeext'
6568  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6569  (eval $ac_try) 2>&5
6570  ac_status=$?
6571  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6572  (exit $ac_status); }; }; then
6573  ac_cv_prog_lex_yytext_pointer=yes
6574 else
6575  echo "$as_me: failed program was:" >&5
6576 sed 's/^/| /' conftest.$ac_ext >&5
6577
6578 fi
6579 rm -f conftest.err conftest.$ac_objext \
6580      conftest$ac_exeext conftest.$ac_ext
6581 LIBS=$ac_save_LIBS
6582 rm -f "${LEX_OUTPUT_ROOT}.c"
12936  
12937   fi
6585 echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
6586 echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
6587 if test $ac_cv_prog_lex_yytext_pointer = yes; then
12938  
6589 cat >>confdefs.h <<\_ACEOF
6590 #define YYTEXT_POINTER 1
6591 _ACEOF
12939  
12940   fi
12941  
12942 < fi
12943 < # Extract the first word of "ar", so it can be a program name with args.
6597 < set dummy ar; ac_word=$2
6598 < echo "$as_me:$LINENO: checking for $ac_word" >&5
6599 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6600 < if test "${ac_cv_prog_AR+set}" = set; then
6601 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6602 < else
6603 <  if test -n "$AR"; then
6604 <  ac_cv_prog_AR="$AR" # Let the user override the test.
6605 < else
6606 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6607 < for as_dir in $PATH
6608 < do
6609 <  IFS=$as_save_IFS
6610 <  test -z "$as_dir" && as_dir=.
6611 <  for ac_exec_ext in '' $ac_executable_extensions; do
6612 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6613 <    ac_cv_prog_AR="ar"
6614 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6615 <    break 2
6616 <  fi
6617 < done
6618 < done
12942 >     ;;
12943 > esac
12944  
6620  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
6621 fi
6622 fi
6623 AR=$ac_cv_prog_AR
6624 if test -n "$AR"; then
6625  echo "$as_me:$LINENO: result: $AR" >&5
6626 echo "${ECHO_T}$AR" >&6
6627 else
6628  echo "$as_me:$LINENO: result: no" >&5
6629 echo "${ECHO_T}no" >&6
6630 fi
12945  
12946 < if test "$AR" = "NONE"; then
12947 <  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
6634 < echo "$as_me: error: --> Can't find \`ar'!" >&2;}
6635 <   { (exit 1); exit 1; }; }
6636 <  cat >confcache <<\_ACEOF
6637 < # This file is a shell script that caches the results of configure
6638 < # tests run on this system so they can be shared between configure
6639 < # scripts and configure runs, see configure's option --config-cache.
6640 < # It is not useful on other systems.  If it contains results you don't
6641 < # want to keep, you may remove or edit it.
6642 < #
6643 < # config.status only pays attention to the cache file if you give it
6644 < # the --recheck option to rerun configure.
6645 < #
6646 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
6647 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
6648 < # following values.
6649 <
12946 > cat >>confdefs.h <<\_ACEOF
12947 > #define OBAPI
12948   _ACEOF
12949  
6652 # The following way of writing the cache mishandles newlines in values,
6653 # but we know of no workaround that is simple, portable, and efficient.
6654 # So, don't put newlines in cache variables' values.
6655 # Ultrix sh set writes to stderr and can't be redirected directly,
6656 # and sets the high bit in the cache file unless we assign to the vars.
6657 {
6658  (set) 2>&1 |
6659    case `(ac_space=' '; set | grep ac_space) 2>&1` in
6660    *ac_space=\ *)
6661      # `set' does not quote correctly, so add quotes (double-quote
6662      # substitution turns \\\\ into \\, and sed turns \\ into \).
6663      sed -n \
6664        "s/'/'\\\\''/g;
6665          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
6666      ;;
6667    *)
6668      # `set' quotes correctly as required by POSIX, so do not add quotes.
6669      sed -n \
6670        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
6671      ;;
6672    esac;
6673 } |
6674  sed '
6675     t clear
6676     : clear
6677     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
6678     t end
6679     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
6680     : end' >>confcache
6681 if diff $cache_file confcache >/dev/null 2>&1; then :; else
6682  if test -w $cache_file; then
6683    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
6684    cat confcache >$cache_file
6685  else
6686    echo "not updating unwritable cache $cache_file"
6687  fi
6688 fi
6689 rm -f confcache
6690  exit 1
6691 fi
12950  
12951  
12952  
# Line 6720 | Line 12978 | echo '#include <mpi.h>' > conftest.cc
12978   echo "$as_me:$LINENO: checking for mpi.h" >&5
12979   echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
12980   have_mpi_h=0
12981 + rm -f conftest*
12982   echo '#include <mpi.h>' > conftest.cc
12983 < if test -z "`${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1`"; then
12983 > if ${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1 ; then
12984          echo "$as_me:$LINENO: result: yes" >&5
12985   echo "${ECHO_T}yes" >&6
12986          have_mpi_h=1
12987   else
12988 +        if test -s conftest.out ; then
12989 +                cat conftest.out >> config.log
12990 +        fi
12991          echo "$as_me:$LINENO: result: no! Check MPI include paths" >&5
12992   echo "${ECHO_T}no! Check MPI include paths" >&6
12993          USE_MPI="no"
# Line 6743 | Line 13005 | cat >conftest.f90 <<EOF
13005   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13006   have_mpif_h=0
13007   rm -f conftest*
13008 < cat >conftest.f90 <<EOF
13008 > cat >conftest.$ac_ext <<EOF
13009   program main
13010     include 'mpif.h'
13011   end
13012   EOF
13013 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13013 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13014          echo "$as_me:$LINENO: result: yes" >&5
13015   echo "${ECHO_T}yes" >&6
13016          MPI_F90_INC="$MPI_INC_DIR"
# Line 6802 | Line 13064 | int
13064   /* We use char because int might match the return type of a gcc2
13065     builtin and then its argument prototype would still apply.  */
13066   char MPI_Init ();
13067 + #ifdef FC_DUMMY_MAIN
13068 + #ifndef FC_DUMMY_MAIN_EQ_F77
13069 + #  ifdef __cplusplus
13070 +     extern "C"
13071 + #  endif
13072 +   int FC_DUMMY_MAIN() { return 1; }
13073 + #endif
13074 + #endif
13075   int
13076   main ()
13077   {
# Line 6872 | Line 13142 | int
13142   /* We use char because int might match the return type of a gcc2
13143     builtin and then its argument prototype would still apply.  */
13144   char MPI_Init ();
13145 + #ifdef FC_DUMMY_MAIN
13146 + #ifndef FC_DUMMY_MAIN_EQ_F77
13147 + #  ifdef __cplusplus
13148 +     extern "C"
13149 + #  endif
13150 +   int FC_DUMMY_MAIN() { return 1; }
13151 + #endif
13152 + #endif
13153   int
13154   main ()
13155   {
# Line 6943 | Line 13221 | int
13221   /* We use char because int might match the return type of a gcc2
13222     builtin and then its argument prototype would still apply.  */
13223   char MPI_Init ();
13224 + #ifdef FC_DUMMY_MAIN
13225 + #ifndef FC_DUMMY_MAIN_EQ_F77
13226 + #  ifdef __cplusplus
13227 +     extern "C"
13228 + #  endif
13229 +   int FC_DUMMY_MAIN() { return 1; }
13230 + #endif
13231 + #endif
13232   int
13233   main ()
13234   {
# Line 6991 | Line 13277 | fi
13277   fi
13278  
13279   fi
13280 <
6995 < $as_unset ac_cv_lib_mpi_MPI_Init
13280 > $as_unset ac_cv_lib_mpich_MPI_Init
13281   if test x = x"$MPI_LIB"; then
13282 < echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13283 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13284 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13282 >        echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
13283 > echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
13284 > if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
13285    echo $ECHO_N "(cached) $ECHO_C" >&6
13286   else
13287    ac_check_lib_save_LIBS=$LIBS
13288 < LIBS="-lmpi -llam -lpthread $LIBS"
13288 > LIBS="-lmpich "-lpmpich" $LIBS"
13289   cat >conftest.$ac_ext <<_ACEOF
13290   /* confdefs.h.  */
13291   _ACEOF
# Line 7015 | Line 13300 | int
13300   /* We use char because int might match the return type of a gcc2
13301     builtin and then its argument prototype would still apply.  */
13302   char MPI_Init ();
13303 + #ifdef FC_DUMMY_MAIN
13304 + #ifndef FC_DUMMY_MAIN_EQ_F77
13305 + #  ifdef __cplusplus
13306 +     extern "C"
13307 + #  endif
13308 +   int FC_DUMMY_MAIN() { return 1; }
13309 + #endif
13310 + #endif
13311   int
13312   main ()
13313   {
# Line 7045 | Line 13338 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13338    ac_status=$?
13339    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13340    (exit $ac_status); }; }; then
13341 <  ac_cv_lib_mpi_MPI_Init=yes
13341 >  ac_cv_lib_mpich_MPI_Init=yes
13342   else
13343    echo "$as_me: failed program was:" >&5
13344   sed 's/^/| /' conftest.$ac_ext >&5
13345  
13346 < ac_cv_lib_mpi_MPI_Init=no
13346 > ac_cv_lib_mpich_MPI_Init=no
13347   fi
13348   rm -f conftest.err conftest.$ac_objext \
13349        conftest$ac_exeext conftest.$ac_ext
13350   LIBS=$ac_check_lib_save_LIBS
13351   fi
13352 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13353 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13354 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
13355 <  MPI_LIB="-lmpi -llam -lpthread"
7063 < else
7064 <
7065 <             { { echo "$as_me:$LINENO: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&5
7066 < echo "$as_me: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&2;}
7067 <   { (exit 1); exit 1; }; }
7068 <             USE_MPI="no"
7069 <
13352 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13353 > echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13354 > if test $ac_cv_lib_mpich_MPI_Init = yes; then
13355 >  MPI_LIB="-lpmpich -lmpich"
13356   fi
13357  
13358   fi
13359  
13360 <
13361 <
13362 < echo "$as_me:$LINENO: checking for MPI Fortran library" >&5
13363 < echo $ECHO_N "checking for MPI Fortran library... $ECHO_C" >&6
13364 < MPI_F90_LIB=""
7079 < if test -f "$MPI_LIB_DIR/libfmpich.a" ; then
7080 <        MPI_F90_LIB="-lfmpich"
7081 < elif test -f "$MPI_LIB_DIR/liblamf77mpi.a" ; then
7082 <        MPI_F90_LIB="-llamf77mpi"
7083 < else
7084 <                        MPI_F90_LIB="  "
7085 < fi
7086 < echo "$as_me:$LINENO: result: found $MPI_F90_LIB" >&5
7087 < echo "${ECHO_T}found $MPI_F90_LIB" >&6
7088 <
7089 <
7090 < fi
7091 <
7092 <
7093 <
7094 < # Check whether --with-sprng or --without-sprng was given.
7095 < if test "${with_sprng+set}" = set; then
7096 <  withval="$with_sprng"
7097 <  with_sprng=$withval
7098 < else
7099 <  with_sprng="/usr/local"
7100 < fi;
7101 <
7102 < case "x$with_sprng" in
7103 <        xyes | "x")  USE_SPRNG=yes;;
7104 <        xno) USE_SPRNG=no ;;
7105 <        *) SPRNG="$with_sprng"; USE_SPRNG=yes ;;
7106 < esac
7107 < if test "$USE_SPRNG" = "yes" -a -z "$with_sprng"; then
7108 <        SPRNG="/usr/local"
7109 < fi
7110 < if test "$USE_SPRNG" = "yes"; then
7111 <
7112 <
7113 < # Set variables...
7114 < SPRNG_LIB_DIR="$SPRNG/lib"
7115 < SPRNG_INC_DIR="$SPRNG/include"
7116 <
7117 <
7118 <
7119 < echo "$as_me:$LINENO: checking for sprng.h" >&5
7120 < echo $ECHO_N "checking for sprng.h... $ECHO_C" >&6
7121 < have_sprng_h=0
7122 < echo '#include <sprng.h>' > conftest.cc
7123 < if test -z "`${CXX} -I${SPRNG_INC_DIR} -c conftest.cc 2>&1`"; then
7124 <        echo "$as_me:$LINENO: result: yes" >&5
7125 < echo "${ECHO_T}yes" >&6
7126 <        have_sprng_h=1
7127 < else
7128 <        echo "$as_me:$LINENO: result: no! Check SPRNG include path!" >&5
7129 < echo "${ECHO_T}no! Check SPRNG include path!" >&6
7130 <        USE_SPRNG="no"
7131 < fi
7132 < rm -f conftest*
7133 < if test "$have_sprng_h" = 1; then
7134 <
7135 < cat >>confdefs.h <<\_ACEOF
7136 < #define HAVE_SPRNG_H 1
7137 < _ACEOF
7138 <
7139 < fi
7140 <
7141 < ac_ext=c
7142 < ac_cpp='$CPP $CPPFLAGS'
7143 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7144 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7145 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
7146 <
7147 < ac_save_LDFLAGS=$LDFLAGS
7148 < LDFLAGS="${LDFLAGS} -L${SPRNG_LIB_DIR} "
7149 <
7150 < echo "$as_me:$LINENO: checking for init_rng in -lsprng" >&5
7151 < echo $ECHO_N "checking for init_rng in -lsprng... $ECHO_C" >&6
7152 < if test "${ac_cv_lib_sprng_init_rng+set}" = set; then
13360 > $as_unset ac_cv_lib_mpi_MPI_Init
13361 > if test x = x"$MPI_LIB"; then
13362 > echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13363 > echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13364 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13365    echo $ECHO_N "(cached) $ECHO_C" >&6
13366   else
13367    ac_check_lib_save_LIBS=$LIBS
13368 < LIBS="-lsprng  $LIBS"
13368 > LIBS="-lmpi -llam -lpthread $LIBS"
13369   cat >conftest.$ac_ext <<_ACEOF
13370   /* confdefs.h.  */
13371   _ACEOF
# Line 7167 | Line 13379 | char init_rng ();
13379   #endif
13380   /* We use char because int might match the return type of a gcc2
13381     builtin and then its argument prototype would still apply.  */
13382 < char init_rng ();
13382 > char MPI_Init ();
13383 > #ifdef FC_DUMMY_MAIN
13384 > #ifndef FC_DUMMY_MAIN_EQ_F77
13385 > #  ifdef __cplusplus
13386 >     extern "C"
13387 > #  endif
13388 >   int FC_DUMMY_MAIN() { return 1; }
13389 > #endif
13390 > #endif
13391   int
13392   main ()
13393   {
13394 < init_rng ();
13394 > MPI_Init ();
13395    ;
13396    return 0;
13397   }
# Line 7198 | Line 13418 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13418    ac_status=$?
13419    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13420    (exit $ac_status); }; }; then
13421 <  ac_cv_lib_sprng_init_rng=yes
13421 >  ac_cv_lib_mpi_MPI_Init=yes
13422   else
13423    echo "$as_me: failed program was:" >&5
13424   sed 's/^/| /' conftest.$ac_ext >&5
13425  
13426 < ac_cv_lib_sprng_init_rng=no
13426 > ac_cv_lib_mpi_MPI_Init=no
13427   fi
13428   rm -f conftest.err conftest.$ac_objext \
13429        conftest$ac_exeext conftest.$ac_ext
13430   LIBS=$ac_check_lib_save_LIBS
13431   fi
13432 < echo "$as_me:$LINENO: result: $ac_cv_lib_sprng_init_rng" >&5
13433 < echo "${ECHO_T}$ac_cv_lib_sprng_init_rng" >&6
13434 < if test $ac_cv_lib_sprng_init_rng = yes; then
13435 <  SPRNG_LIB="-lsprng"
13432 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13433 > echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13434 > if test $ac_cv_lib_mpi_MPI_Init = yes; then
13435 >  MPI_LIB="-lmpi -llam -lpthread"
13436   else
13437  
13438 <             { { echo "$as_me:$LINENO: error: Didn't find libsprng; check path for SPRNG package first..." >&5
13439 < echo "$as_me: error: Didn't find libsprng; check path for SPRNG package first..." >&2;}
13438 >             { { echo "$as_me:$LINENO: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&5
13439 > echo "$as_me: error: Didn't find liblam, libmpi, or libmpich; check path for MPI package first..." >&2;}
13440     { (exit 1); exit 1; }; }
13441 <             USE_SPRNG="no"
13441 >             USE_MPI="no"
13442  
13443   fi
13444  
13445 + fi
13446  
13447 < if test "$USE_SPRNG" = "no"; then
13448 <  { { echo "$as_me:$LINENO: error: No working SPRNG library found" >&5
13449 < echo "$as_me: error: No working SPRNG library found" >&2;}
13450 <   { (exit 1); exit 1; }; }
13447 >
13448 >
13449 > echo "$as_me:$LINENO: checking for MPI Fortran library" >&5
13450 > echo $ECHO_N "checking for MPI Fortran library... $ECHO_C" >&6
13451 > MPI_F90_LIB=""
13452 > if test -f "$MPI_LIB_DIR/libfmpich.a" ; then
13453 >        MPI_F90_LIB="-lfmpich"
13454 > elif test -f "$MPI_LIB_DIR/liblamf77mpi.a" ; then
13455 >        MPI_F90_LIB="-llamf77mpi"
13456 > else
13457 >                        MPI_F90_LIB="  "
13458   fi
13459 + echo "$as_me:$LINENO: result: found $MPI_F90_LIB" >&5
13460 + echo "${ECHO_T}found $MPI_F90_LIB" >&6
13461  
13462  
13463   fi
13464  
13465  
13466  
13467 < echo "$as_me:$LINENO: checking if MKL is wanted" >&5
13468 < echo $ECHO_N "checking if MKL is wanted... $ECHO_C" >&6
13467 > USE_CGAL=no
13468 > cgal_makefile=auto
13469  
13470 < # Check whether --with-mkl or --without-mkl was given.
13471 < if test "${with_mkl+set}" = set; then
13472 <  withval="$with_mkl"
13473 <     echo "$as_me:$LINENO: result: yes" >&5
13474 < echo "${ECHO_T}yes" >&6
7245 <    for dir in $withval /usr/local/intel/mkl61 /opt/intel/mkl61; do
7246 <        mkldir="$dir"
7247 <        if test -f "$dir/include/mkl.h"; then
7248 <            found_mkl="yes";
7249 <            break;
7250 <        fi
7251 <    done
7252 <    if test x_$found_mkl != x_yes; then
7253 <        { { echo "$as_me:$LINENO: error: Cannot find MKL includes" >&5
7254 < echo "$as_me: error: Cannot find MKL includes" >&2;}
7255 <   { (exit 1); exit 1; }; }
7256 <    else
7257 <        printf "MKL includes found in $mkldir/include\n";
7258 <    fi
13470 > # Check whether --with-cgal-makefile or --without-cgal-makefile was given.
13471 > if test "${with_cgal_makefile+set}" = set; then
13472 >  withval="$with_cgal_makefile"
13473 >  cgal_makefile="$withval"
13474 > fi;
13475  
13476 + if test "x$cgal_makefile" != xno; then
13477  
13478 +  if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
13479 +    cgal_makefile="$CGAL_MAKEFILE"
13480 +  fi
13481  
13482 <  ac_ext=c
13483 < ac_cpp='$CPP $CPPFLAGS'
7264 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7265 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7266 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
13482 >  echo "$as_me:$LINENO: checking for cgal_makefile: $cgal_makefile" >&5
13483 > echo $ECHO_N "checking for cgal_makefile: $cgal_makefile... $ECHO_C" >&6
13484  
13485 <  ac_save_CPPFLAGS=$CPPFLAGS
13486 <  CPPFLAGS="${CPPFLAGS} -I${mkldir}/include"
13487 <  ac_save_LDFLAGS=$LDFLAGS
13488 <  LDFLAGS="${LDFLAGS} -L${mkldir}/lib/32 -lmkl -lvml -lguide"
13489 <  if test "${ac_cv_header_mkl_h+set}" = set; then
13490 <  echo "$as_me:$LINENO: checking for mkl.h" >&5
13491 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
13492 < if test "${ac_cv_header_mkl_h+set}" = set; then
13485 >  if test -f "$cgal_makefile"; then
13486 >
13487 >    cat >config.tmp.Makefile <<EOF
13488 > include $cgal_makefile
13489 > default:
13490 >        @echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
13491 >        @echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
13492 >        @echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
13493 >        @echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13494 >        @echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
13495 >        @echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
13496 >        @echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
13497 >        @echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13498 >        @echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
13499 >        @echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
13500 >        @echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13501 >        @echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
13502 > EOF
13503 >
13504 >    make -s -f config.tmp.Makefile
13505 >    . config.tmp.cgalvariables
13506 >
13507 >    rm -f config.tmp.Makefile config.tmp.cgalvariables
13508 >
13509 >    if test "x$CGAL_INCLDIR" = "x"; then
13510 >      CGAL_INCLDIR=""
13511 >    fi
13512 >
13513 >    if test "x$CGAL_LIBDIR" = "x"; then
13514 >      CGAL_LIBDIR=""
13515 >    fi
13516 >
13517 >    if test "x$CGAL_RLIBDIR" = "x"; then
13518 >      CGAL_RLIBDIR=""
13519 >    fi
13520 >
13521 >    if test "x$LEDA_INCLDIR" = "x"; then
13522 >      LEDA_INCLDIR=""
13523 >    fi
13524 >
13525 >    if test "x$LEDA_LIBDIR" = "x"; then
13526 >      LEDA_LIBDIR=""
13527 >    fi
13528 >
13529 >    if test "x$LEDA_RLIBDIR" = "x"; then
13530 >      LEDA_RLIBDIR=""
13531 >    fi
13532 >
13533 >    if test "x$GMP_INCLDIR" = "x"; then
13534 >      GMP_INCLDIR=""
13535 >    fi
13536 >
13537 >    if test "x$GMP_LIBDIR" = "x"; then
13538 >      GMP_LIBDIR=""
13539 >    fi
13540 >
13541 >    if test "x$GMP_RLIBDIR" = "x"; then
13542 >      GMP_RLIBDIR=""
13543 >    fi
13544 >
13545 >    echo "$as_me:$LINENO: result: CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&5
13546 > echo "${ECHO_T}CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&6
13547 >    echo "$as_me:$LINENO: result: CGAL_INCLDIR=       $CGAL_INCLDIR" >&5
13548 > echo "${ECHO_T}CGAL_INCLDIR=       $CGAL_INCLDIR" >&6
13549 >    echo "$as_me:$LINENO: result: CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&5
13550 > echo "${ECHO_T}CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&6
13551 >    echo "$as_me:$LINENO: result: CGAL_LIBDIR=        $CGAL_LIBDIR" >&5
13552 > echo "${ECHO_T}CGAL_LIBDIR=        $CGAL_LIBDIR" >&6
13553 >    echo "$as_me:$LINENO: result: CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&5
13554 > echo "${ECHO_T}CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&6
13555 >    echo "$as_me:$LINENO: result: LEDA_INCLDIR=       $LEDA_INCLDIR" >&5
13556 > echo "${ECHO_T}LEDA_INCLDIR=       $LEDA_INCLDIR" >&6
13557 >    echo "$as_me:$LINENO: result: LEDA_LIBDIR=        $LEDA_LIBDIR" >&5
13558 > echo "${ECHO_T}LEDA_LIBDIR=        $LEDA_LIBDIR" >&6
13559 >    echo "$as_me:$LINENO: result: GMP_INCLDIR=        $GMP_INCLDIR" >&5
13560 > echo "${ECHO_T}GMP_INCLDIR=        $GMP_INCLDIR" >&6
13561 >    echo "$as_me:$LINENO: result: GMP_LIBDIR=         $GMP_LIBDIR" >&5
13562 > echo "${ECHO_T}GMP_LIBDIR=         $GMP_LIBDIR" >&6
13563 >
13564 >    ac_ext=cc
13565 > ac_cpp='$CXXCPP $CPPFLAGS'
13566 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13567 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13568 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
13569 >
13570 >    save_CXXFLAGS="$CXXFLAGS"
13571 >    CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13572 >    if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13573 >  echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13574 > echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13575 > if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13576    echo $ECHO_N "(cached) $ECHO_C" >&6
13577   fi
13578 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
13579 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
13578 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13579 > echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13580   else
13581    # Is the header compilable?
13582 < echo "$as_me:$LINENO: checking mkl.h usability" >&5
13583 < echo $ECHO_N "checking mkl.h usability... $ECHO_C" >&6
13582 > echo "$as_me:$LINENO: checking CGAL/Cartesian.h usability" >&5
13583 > echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
13584   cat >conftest.$ac_ext <<_ACEOF
13585   /* confdefs.h.  */
13586   _ACEOF
# Line 7288 | Line 13588 | $ac_includes_default
13588   cat >>conftest.$ac_ext <<_ACEOF
13589   /* end confdefs.h.  */
13590   $ac_includes_default
13591 < #include <mkl.h>
13591 > #include <CGAL/Cartesian.h>
13592   _ACEOF
13593   rm -f conftest.$ac_objext
13594   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 7299 | Line 13599 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
13599    cat conftest.err >&5
13600    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13601    (exit $ac_status); } &&
13602 <         { ac_try='test -z "$ac_c_werror_flag"
13602 >         { ac_try='test -z "$ac_cxx_werror_flag"
13603                           || test ! -s conftest.err'
13604    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13605    (eval $ac_try) 2>&5
# Line 7324 | Line 13624 | echo "$as_me:$LINENO: checking mkl.h presence" >&5
13624   echo "${ECHO_T}$ac_header_compiler" >&6
13625  
13626   # Is the header present?
13627 < echo "$as_me:$LINENO: checking mkl.h presence" >&5
13628 < echo $ECHO_N "checking mkl.h presence... $ECHO_C" >&6
13627 > echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
13628 > echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
13629   cat >conftest.$ac_ext <<_ACEOF
13630   /* confdefs.h.  */
13631   _ACEOF
13632   cat confdefs.h >>conftest.$ac_ext
13633   cat >>conftest.$ac_ext <<_ACEOF
13634   /* end confdefs.h.  */
13635 < #include <mkl.h>
13635 > #include <CGAL/Cartesian.h>
13636   _ACEOF
13637   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
13638    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 7343 | Line 13643 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
13643    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13644    (exit $ac_status); } >/dev/null; then
13645    if test -s conftest.err; then
13646 <    ac_cpp_err=$ac_c_preproc_warn_flag
13647 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
13646 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
13647 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
13648    else
13649      ac_cpp_err=
13650    fi
# Line 7364 | Line 13664 | case $ac_header_compiler:$ac_header_preproc:$ac_c_prep
13664   echo "${ECHO_T}$ac_header_preproc" >&6
13665  
13666   # So?  What about this header?
13667 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
13667 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
13668    yes:no: )
13669 <    { echo "$as_me:$LINENO: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&5
13670 < echo "$as_me: WARNING: mkl.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13671 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the compiler's result" >&5
13672 < echo "$as_me: WARNING: mkl.h: proceeding with the compiler's result" >&2;}
13669 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
13670 > echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
13671 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
13672 > echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
13673      ac_header_preproc=yes
13674      ;;
13675    no:yes:* )
13676 <    { echo "$as_me:$LINENO: WARNING: mkl.h: present but cannot be compiled" >&5
13677 < echo "$as_me: WARNING: mkl.h: present but cannot be compiled" >&2;}
13678 <    { echo "$as_me:$LINENO: WARNING: mkl.h:     check for missing prerequisite headers?" >&5
13679 < echo "$as_me: WARNING: mkl.h:     check for missing prerequisite headers?" >&2;}
13680 <    { echo "$as_me:$LINENO: WARNING: mkl.h: see the Autoconf documentation" >&5
13681 < echo "$as_me: WARNING: mkl.h: see the Autoconf documentation" >&2;}
13682 <    { echo "$as_me:$LINENO: WARNING: mkl.h:     section \"Present But Cannot Be Compiled\"" >&5
13683 < echo "$as_me: WARNING: mkl.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13684 <    { echo "$as_me:$LINENO: WARNING: mkl.h: proceeding with the preprocessor's result" >&5
13685 < echo "$as_me: WARNING: mkl.h: proceeding with the preprocessor's result" >&2;}
13686 <    { echo "$as_me:$LINENO: WARNING: mkl.h: in the future, the compiler will take precedence" >&5
13687 < echo "$as_me: WARNING: mkl.h: in the future, the compiler will take precedence" >&2;}
13676 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&5
13677 > echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
13678 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
13679 > echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
13680 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
13681 > echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
13682 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
13683 > echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
13684 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
13685 > echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
13686 >    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
13687 > echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
13688      (
13689        cat <<\_ASBOX
13690   ## ------------------------------ ##
# Line 7395 | Line 13695 | echo "$as_me:$LINENO: checking for mkl.h" >&5
13695        sed "s/^/$as_me: WARNING:     /" >&2
13696      ;;
13697   esac
13698 < echo "$as_me:$LINENO: checking for mkl.h" >&5
13699 < echo $ECHO_N "checking for mkl.h... $ECHO_C" >&6
13700 < if test "${ac_cv_header_mkl_h+set}" = set; then
13698 > echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
13699 > echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
13700 > if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
13701    echo $ECHO_N "(cached) $ECHO_C" >&6
13702   else
13703 <  ac_cv_header_mkl_h=$ac_header_preproc
13703 >  ac_cv_header_CGAL_Cartesian_h=$ac_header_preproc
13704   fi
13705 < echo "$as_me:$LINENO: result: $ac_cv_header_mkl_h" >&5
13706 < echo "${ECHO_T}$ac_cv_header_mkl_h" >&6
13705 > echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
13706 > echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
13707  
13708   fi
13709 < if test $ac_cv_header_mkl_h = yes; then
13710 <
7411 <    echo "$as_me:$LINENO: checking for vslNewStream in -lmkl" >&5
7412 < echo $ECHO_N "checking for vslNewStream in -lmkl... $ECHO_C" >&6
7413 < if test "${ac_cv_lib_mkl_vslNewStream+set}" = set; then
7414 <  echo $ECHO_N "(cached) $ECHO_C" >&6
13709 > if test $ac_cv_header_CGAL_Cartesian_h = yes; then
13710 >  cgal=yes
13711   else
13712 <  ac_check_lib_save_LIBS=$LIBS
13713 < LIBS="-lmkl  $LIBS"
13712 >  cgal=no
13713 > fi
13714 >
13715 >
13716 >    CXXFLAGS="$save_CXXFLAGS"
13717 >
13718 >    if test "x$cgal" = xyes; then
13719 >      echo "$as_me:$LINENO: checking for CGAL version" >&5
13720 > echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
13721 >      LOCATION=${CGAL_INCLDIR}
13722 >      LOCATION=${LOCATION:-/usr/include}
13723 >      if test -f $LOCATION/CGAL/version.h; then
13724 >        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
13725 >      else
13726 >        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
13727 >      fi
13728 >      if echo $CGAL_VERSION | grep -q "^[3456789]"; then
13729 >        echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
13730 > echo "${ECHO_T}($CGAL_VERSION) yes" >&6
13731 >      else
13732 >        echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
13733 > echo "${ECHO_T}($CGAL_VERSION) no" >&6
13734 >        cgal=no
13735 >      fi
13736 >    fi
13737 >
13738 >    if test "x$cgal" = xyes; then
13739 >      CGAL_LIBS="-lCGAL"
13740 >      echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
13741 > echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
13742 >      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
13743 >        CGAL_USES_LEDA=yes
13744 >        echo "$as_me:$LINENO: result: yes" >&5
13745 > echo "${ECHO_T}yes" >&6
13746 >        CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
13747 >      else
13748 >        echo "$as_me:$LINENO: result: no" >&5
13749 > echo "${ECHO_T}no" >&6
13750 >        CGAL_USES_LEDA=no
13751 >      fi
13752 >
13753 >      echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
13754 > echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
13755 >      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
13756 >        CGAL_USES_GMP=yes
13757 >        echo "$as_me:$LINENO: result: yes" >&5
13758 > echo "${ECHO_T}yes" >&6
13759 >        CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
13760 >      else
13761 >        echo "$as_me:$LINENO: result: no" >&5
13762 > echo "${ECHO_T}no" >&6
13763 >        CGAL_USES_GMP=no
13764 >      fi
13765 >
13766 >      CGAL_LIBS="$CGAL_LIBS -lm"
13767 >
13768 >      CGAL_CXXFLAGS="-ftemplate-depth-50"
13769 >
13770 >      echo "$as_me:$LINENO: result: CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&5
13771 > echo "${ECHO_T}CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&6
13772 >      echo "$as_me:$LINENO: result: CGAL_USES_GMP =     $CGAL_USES_GMP" >&5
13773 > echo "${ECHO_T}CGAL_USES_GMP =     $CGAL_USES_GMP" >&6
13774 >      echo "$as_me:$LINENO: result: CGAL_INCLDIR  =     $CGAL_INCLDIR" >&5
13775 > echo "${ECHO_T}CGAL_INCLDIR  =     $CGAL_INCLDIR" >&6
13776 >      echo "$as_me:$LINENO: result: CGAL_LIBDIR   =     $CGAL_LIBDIR" >&5
13777 > echo "${ECHO_T}CGAL_LIBDIR   =     $CGAL_LIBDIR" >&6
13778 >      echo "$as_me:$LINENO: result: CGAL_DEFINES  =     $CGAL_DEFINES" >&5
13779 > echo "${ECHO_T}CGAL_DEFINES  =     $CGAL_DEFINES" >&6
13780 >      echo "$as_me:$LINENO: result: CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&5
13781 > echo "${ECHO_T}CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&6
13782 >      echo "$as_me:$LINENO: result: CGAL_LIBS     =     $CGAL_LIBS" >&5
13783 > echo "${ECHO_T}CGAL_LIBS     =     $CGAL_LIBS" >&6
13784 >    fi
13785 >
13786 >    if test "x$cgal" = xyes; then
13787 >      save_LIBS="$LIBS"
13788 >      LIBS="$LIBS -L$CGAL_LIBDIR"
13789 >      if test "x$CGAL_USES_LEDA" = xyes; then
13790 >        LIBS="-lL $LIBS -L$LEDA_LIBDIR"
13791 >      fi
13792 >      # if test "x$CGAL_USES_GMP" = xyes; then
13793 >      #   LIBS="-lgmp $LIBS $GMP_LIBDIR"
13794 >      # fi
13795 >      echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
13796 > echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
13797 > save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
13798 > CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
13799 > save_LIBS_CHECK_CXX_LIB="$LIBS"
13800 > LIBS="-lCGAL  $LIBS"
13801   cat >conftest.$ac_ext <<_ACEOF
13802   /* confdefs.h.  */
13803   _ACEOF
13804   cat confdefs.h >>conftest.$ac_ext
13805   cat >>conftest.$ac_ext <<_ACEOF
13806   /* end confdefs.h.  */
13807 <
13808 < /* Override any gcc2 internal prototype to avoid an error.  */
13809 < #ifdef __cplusplus
13810 < extern "C"
13807 > #include <CGAL/Cartesian.h>
13808 > #ifdef FC_DUMMY_MAIN
13809 > #ifndef FC_DUMMY_MAIN_EQ_F77
13810 > #  ifdef __cplusplus
13811 >     extern "C"
13812 > #  endif
13813 >   int FC_DUMMY_MAIN() { return 1; }
13814   #endif
13815 < /* We use char because int might match the return type of a gcc2
7430 <   builtin and then its argument prototype would still apply.  */
7431 < char vslNewStream ();
13815 > #endif
13816   int
13817   main ()
13818   {
13819 < vslNewStream ();
13819 > ::CGAL::Cartesian<int>::Point_2 P
13820    ;
13821    return 0;
13822   }
# Line 7446 | Line 13830 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13830    cat conftest.err >&5
13831    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13832    (exit $ac_status); } &&
13833 <         { ac_try='test -z "$ac_c_werror_flag"
13833 >         { ac_try='test -z "$ac_cxx_werror_flag"
13834                           || test ! -s conftest.err'
13835    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13836    (eval $ac_try) 2>&5
# Line 7459 | Line 13843 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13843    ac_status=$?
13844    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13845    (exit $ac_status); }; }; then
13846 <  ac_cv_lib_mkl_vslNewStream=yes
13846 >  echo "$as_me:$LINENO: result: yes" >&5
13847 > echo "${ECHO_T}yes" >&6
13848 > cgal=yes
13849   else
13850    echo "$as_me: failed program was:" >&5
13851   sed 's/^/| /' conftest.$ac_ext >&5
13852  
13853 < ac_cv_lib_mkl_vslNewStream=no
13853 > echo "$as_me:$LINENO: result: no" >&5
13854 > echo "${ECHO_T}no" >&6
13855 > cgal=no
13856   fi
13857   rm -f conftest.err conftest.$ac_objext \
13858        conftest$ac_exeext conftest.$ac_ext
13859 < LIBS=$ac_check_lib_save_LIBS
13860 < fi
13861 < echo "$as_me:$LINENO: result: $ac_cv_lib_mkl_vslNewStream" >&5
13862 < echo "${ECHO_T}$ac_cv_lib_mkl_vslNewStream" >&6
7475 < if test $ac_cv_lib_mkl_vslNewStream = yes; then
7476 <  MKL_LIBDIR="${mkldir}/lib/32",
7477 <                     MKL_LIB="-lmkl -lvml -lguide",
7478 <                     HAVE_MKL="yes"
7479 < fi
13859 > CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
13860 > LIBS="$save_LIBS_CHECK_CXX_LIB"
13861 >      LIBS="$save_LIBS"
13862 >    fi
13863  
13864 <
7482 < else
7483 <  MKL_INC="-I${mkldir}/include"
7484 < fi
7485 <
7486 <
7487 <  CPPFLAGS=$ac_save_CPPFLAGS
7488 <  LDFLAGS=$ac_save_LDFLAGS
13864 >  fi
13865    ac_ext=c
13866   ac_cpp='$CPP $CPPFLAGS'
13867   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 7493 | Line 13869 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
13869   ac_compiler_gnu=$ac_cv_c_compiler_gnu
13870  
13871  
13872 <  if test x_$HAVE_MKL != x_yes; then
7497 <        { { echo "$as_me:$LINENO: error: Can't build with MKL" >&5
7498 < echo "$as_me: error: Can't build with MKL" >&2;}
7499 <   { (exit 1); exit 1; }; }
7500 <  fi
13872 > fi
13873  
13874 + if test "x$cgal" = xyes; then
13875 +  USE_CGAL=yes
13876  
13877 + cat >>confdefs.h <<\_ACEOF
13878 + #define HAVE_CGAL 1
13879 + _ACEOF
13880  
13881  
13882 + cat >>confdefs.h <<_ACEOF
13883 + #define CGAL_VERSION $CGAL_VERSION
13884 + _ACEOF
13885  
13886 +  if ! echo $CGAL_VERSION | grep -q "^3.0"; then
13887 +    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
13888 + echo "$as_me: WARNING: *****************************************************" >&2;}
13889 +    { echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
13890 + echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
13891 +    { echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
13892 + echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
13893 +    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
13894 + echo "$as_me: WARNING: *****************************************************" >&2;}
13895 +  fi
13896   else
13897 +   if test "x$cgal_makefile" != xno; then
13898 +    echo "$as_me:$LINENO: result: No CGAL support. These are not the droids you want." >&5
13899 + echo "${ECHO_T}No CGAL support. These are not the droids you want." >&6
13900 +  fi
13901 +  CGAL_INCLDIR=
13902 +  CGAL_LIBDIR=
13903 +  CGAL_RLIBDIR=
13904 +  CGAL_DEFINES=
13905 +  CGAL_CXXFLAGS=
13906 +  CGAL_LIBS=
13907 + fi
13908  
7508    echo "$as_me:$LINENO: result: no" >&5
7509 echo "${ECHO_T}no" >&6
13909  
13910 < fi;
13910 > CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
13911  
13912 + CGAL_LIB_DIR=${CGAL_LIBDIR}
13913  
13914 + CGAL_RLIB_DIR=${CGAL_RLIBDIR}
13915  
13916  
13917  
7517 OBJEXT=".$OBJEXT"
13918  
7519 OOPSE=oopse
13919  
13920 < if test "x${prefix}" = "xNONE"
13921 < then
13922 <  OOPSE_HOME=${ac_default_prefix}/oopse
13920 >
13921 > # Check whether --enable-doxygen or --disable-doxygen was given.
13922 > if test "${enable_doxygen+set}" = set; then
13923 >  enableval="$enable_doxygen"
13924 >
13925 > fi;
13926 > # Check whether --enable-dot or --disable-dot was given.
13927 > if test "${enable_dot+set}" = set; then
13928 >  enableval="$enable_dot"
13929 >
13930 > fi;
13931 > # Check whether --enable-html-docs or --disable-html-docs was given.
13932 > if test "${enable_html_docs+set}" = set; then
13933 >  enableval="$enable_html_docs"
13934 >
13935   else
13936 <  OOPSE_HOME=${prefix}/oopse
7526 < fi
7527 < # Check whether --enable-oopse-home or --disable-oopse-home was given.
7528 < if test "${enable_oopse_home+set}" = set; then
7529 <  enableval="$enable_oopse_home"
7530 <  OOPSE_HOME="${enableval}"
13936 >   enable_html_docs=yes
13937   fi;
13938 + # Check whether --enable-latex-docs or --disable-latex-docs was given.
13939 + if test "${enable_latex_docs+set}" = set; then
13940 +  enableval="$enable_latex_docs"
13941  
13942 < case "x$INSTALL" in
13943 <   x/*) ;;
13944 <   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
13942 > else
13943 >   enable_latex_docs=no
13944 > fi;
13945 > if test "x$enable_doxygen" = xno; then
13946 >        enable_doc=no
13947 > else
13948 >        # Extract the first word of "doxygen", so it can be a program name with args.
13949 > set dummy doxygen; ac_word=$2
13950 > echo "$as_me:$LINENO: checking for $ac_word" >&5
13951 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
13952 > if test "${ac_cv_path_DOXYGEN+set}" = set; then
13953 >  echo $ECHO_N "(cached) $ECHO_C" >&6
13954 > else
13955 >  case $DOXYGEN in
13956 >  [\\/]* | ?:[\\/]*)
13957 >  ac_cv_path_DOXYGEN="$DOXYGEN" # Let the user override the test with a path.
13958 >  ;;
13959 >  *)
13960 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13961 > for as_dir in $PATH
13962 > do
13963 >  IFS=$as_save_IFS
13964 >  test -z "$as_dir" && as_dir=.
13965 >  for ac_exec_ext in '' $ac_executable_extensions; do
13966 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
13967 >    ac_cv_path_DOXYGEN="$as_dir/$ac_word$ac_exec_ext"
13968 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
13969 >    break 2
13970 >  fi
13971 > done
13972 > done
13973 >
13974 >  ;;
13975   esac
13976 + fi
13977 + DOXYGEN=$ac_cv_path_DOXYGEN
13978  
13979 < MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
13979 > if test -n "$DOXYGEN"; then
13980 >  echo "$as_me:$LINENO: result: $DOXYGEN" >&5
13981 > echo "${ECHO_T}$DOXYGEN" >&6
13982 > else
13983 >  echo "$as_me:$LINENO: result: no" >&5
13984 > echo "${ECHO_T}no" >&6
13985 > fi
13986  
13987 < CFLAGS=${CFLAGS-""}
13988 < CXXFLAGS=${CXXFLAGS-""}
13989 < CPPFLAGS=${CPPFLAGS-""}
13990 < FFLAGS=${FFLAGS-""}
13991 < F90FLAGS=${F90FLAGS-""}
13992 < LDFLAGS=${LDFLAGS-""}
13993 < DEBUG=${DEBUG-"-g"}
13994 <
13995 < case $debug in
13996 <  1)
13997 <     FFLAGS="$DEBUG $FFLAGS"
13998 <     F90FLAGS="$DEBUG $F90FLAGS"
13999 <     ;;
13987 >        if test "x$DOXYGEN" = x; then
13988 >                if test "x$enable_doxygen" = xyes; then
13989 >                        { { echo "$as_me:$LINENO: error: could not find doxygen" >&5
13990 > echo "$as_me: error: could not find doxygen" >&2;}
13991 >   { (exit 1); exit 1; }; }
13992 >                fi
13993 >                enable_doc=no
13994 >        else
13995 >                enable_doc=yes
13996 >                # Extract the first word of "dot", so it can be a program name with args.
13997 > set dummy dot; ac_word=$2
13998 > echo "$as_me:$LINENO: checking for $ac_word" >&5
13999 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
14000 > if test "${ac_cv_path_DOT+set}" = set; then
14001 >  echo $ECHO_N "(cached) $ECHO_C" >&6
14002 > else
14003 >  case $DOT in
14004 >  [\\/]* | ?:[\\/]*)
14005 >  ac_cv_path_DOT="$DOT" # Let the user override the test with a path.
14006 >  ;;
14007    *)
14008 <     ;;
14008 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
14009 > for as_dir in $PATH
14010 > do
14011 >  IFS=$as_save_IFS
14012 >  test -z "$as_dir" && as_dir=.
14013 >  for ac_exec_ext in '' $ac_executable_extensions; do
14014 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
14015 >    ac_cv_path_DOT="$as_dir/$ac_word$ac_exec_ext"
14016 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
14017 >    break 2
14018 >  fi
14019 > done
14020 > done
14021 >
14022 >  ;;
14023   esac
14024 + fi
14025 + DOT=$ac_cv_path_DOT
14026  
14027 + if test -n "$DOT"; then
14028 +  echo "$as_me:$LINENO: result: $DOT" >&5
14029 + echo "${ECHO_T}$DOT" >&6
14030 + else
14031 +  echo "$as_me:$LINENO: result: no" >&5
14032 + echo "${ECHO_T}no" >&6
14033 + fi
14034  
14035 +        fi
14036 + fi
14037  
14038 + if test "x$enable_doc" = xyes; then
14039 +  DOC=1
14040 + else
14041 +  DOC=0
14042 + fi
14043  
14044  
14045 + if test x$DOT = x; then
14046 +        if test "x$enable_dot" = xyes; then
14047 +                { { echo "$as_me:$LINENO: error: could not find dot" >&5
14048 + echo "$as_me: error: could not find dot" >&2;}
14049 +   { (exit 1); exit 1; }; }
14050 +        fi
14051 +        enable_dot=no
14052 + else
14053 +        enable_dot=yes
14054 + fi
14055  
14056  
14057  
# Line 7570 | Line 14064 | esac
14064  
14065  
14066  
7573          ac_config_headers="$ac_config_headers src/config.h"
14067  
7575          ac_config_files="$ac_config_files make/Make.conf"
14068  
14069  
14070 +
14071 +
14072 +
14073 +
14074 +                                        ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
14075 +
14076 +
14077   cat >confcache <<\_ACEOF
14078   # This file is a shell script that caches the results of configure
14079   # tests run on this system so they can be shared between configure
# Line 7937 | Line 14436 | This file was extended by OOPSE $as_me 2.0, which was
14436   } >&5
14437   cat >&5 <<_CSEOF
14438  
14439 < This file was extended by OOPSE $as_me 2.0, which was
14439 > This file was extended by OOPSE $as_me 3.0, which was
14440   generated by GNU Autoconf 2.59.  Invocation command line was
14441  
14442    CONFIG_FILES    = $CONFIG_FILES
# Line 8000 | Line 14499 | OOPSE config.status 2.0
14499  
14500   cat >>$CONFIG_STATUS <<_ACEOF
14501   ac_cs_version="\\
14502 < OOPSE config.status 2.0
14502 > OOPSE config.status 3.0
14503   configured by $0, generated by GNU Autoconf 2.59,
14504    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14505  
# Line 8103 | Line 14602 | do
14602   do
14603    case "$ac_config_target" in
14604    # Handling of arguments.
14605 <  "make/Make.conf" ) CONFIG_FILES="$CONFIG_FILES make/Make.conf" ;;
14606 <  "utils/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS utils/getopt.h:utils/gnugetopt.h" ;;
14605 >  "make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14606 >  "src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
14607 >  "src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
14608 >  "scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
14609 >  "src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
14610    "src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
14611    *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
14612   echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
# Line 8191 | Line 14693 | s,@PROGNAME@,$PROGNAME,;t t
14693   s,@ECHO_N@,$ECHO_N,;t t
14694   s,@ECHO_T@,$ECHO_T,;t t
14695   s,@LIBS@,$LIBS,;t t
8194 s,@PROGNAME@,$PROGNAME,;t t
8195 s,@debug@,$debug,;t t
14696   s,@build@,$build,;t t
14697   s,@build_cpu@,$build_cpu,;t t
14698   s,@build_vendor@,$build_vendor,;t t
# Line 8201 | Line 14701 | s,@CC@,$CC,;t t
14701   s,@host_cpu@,$host_cpu,;t t
14702   s,@host_vendor@,$host_vendor,;t t
14703   s,@host_os@,$host_os,;t t
14704 < s,@CC@,$CC,;t t
14705 < s,@CFLAGS@,$CFLAGS,;t t
14704 > s,@PROGNAME@,$PROGNAME,;t t
14705 > s,@debug@,$debug,;t t
14706 > s,@CXX@,$CXX,;t t
14707 > s,@CXXFLAGS@,$CXXFLAGS,;t t
14708   s,@LDFLAGS@,$LDFLAGS,;t t
14709   s,@CPPFLAGS@,$CPPFLAGS,;t t
14710 < s,@ac_ct_CC@,$ac_ct_CC,;t t
14710 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14711   s,@EXEEXT@,$EXEEXT,;t t
14712   s,@OBJEXT@,$OBJEXT,;t t
14713 < s,@CXX@,$CXX,;t t
14714 < s,@CXXFLAGS@,$CXXFLAGS,;t t
14715 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14716 < s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
14717 < s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
14718 < s,@F90@,$F90,;t t
8217 < s,@F90FLAGS@,$F90FLAGS,;t t
8218 < s,@ac_ct_F90@,$ac_ct_F90,;t t
8219 < s,@PREPFLAG@,$PREPFLAG,;t t
8220 < s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
8221 < s,@F90LIBS@,$F90LIBS,;t t
8222 < s,@F90_FUNC@,$F90_FUNC,;t t
8223 < s,@F90_FUNC_@,$F90_FUNC_,;t t
8224 < s,@MOD@,$MOD,;t t
8225 < s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
8226 < s,@MODDIRFLAG@,$MODDIRFLAG,;t t
8227 < s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14713 > s,@CC@,$CC,;t t
14714 > s,@CFLAGS@,$CFLAGS,;t t
14715 > s,@ac_ct_CC@,$ac_ct_CC,;t t
14716 > s,@FC@,$FC,;t t
14717 > s,@FCFLAGS@,$FCFLAGS,;t t
14718 > s,@ac_ct_FC@,$ac_ct_FC,;t t
14719   s,@CPP@,$CPP,;t t
14720   s,@EGREP@,$EGREP,;t t
8230 s,@LIBOBJS@,$LIBOBJS,;t t
8231 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
8232 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
8233 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14721   s,@LN_S@,$LN_S,;t t
14722   s,@SET_MAKE@,$SET_MAKE,;t t
14723   s,@RANLIB@,$RANLIB,;t t
14724   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
14725 < s,@YACC@,$YACC,;t t
14726 < s,@LEX@,$LEX,;t t
14727 < s,@LEXLIB@,$LEXLIB,;t t
14728 < s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
14725 > s,@PERLINTERP@,$PERLINTERP,;t t
14726 > s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
14727 > s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
14728 > s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
14729 > s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14730   s,@AR@,$AR,;t t
14731 + s,@PS@,$PS,;t t
14732 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
14733 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
14734 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
14735 + s,@FCLIBS@,$FCLIBS,;t t
14736 + s,@FC_FUNC@,$FC_FUNC,;t t
14737 + s,@FC_FUNC_@,$FC_FUNC_,;t t
14738 + s,@MOD@,$MOD,;t t
14739 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
14740 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
14741 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14742 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14743 + s,@ZLIB_INC_DIR@,$ZLIB_INC_DIR,;t t
14744 + s,@ZLIB_LIB_DIR@,$ZLIB_LIB_DIR,;t t
14745 + s,@ZLIB@,$ZLIB,;t t
14746 + s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
14747 + s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
14748 + s,@FFTW_LIBS@,$FFTW_LIBS,;t t
14749 + s,@LIBOBJS@,$LIBOBJS,;t t
14750 + s,@POW_LIB@,$POW_LIB,;t t
14751 + s,@CXXCPP@,$CXXCPP,;t t
14752 + s,@__func__@,$__func__,;t t
14753   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
14754   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
14755   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
14756   s,@MPI_LIB@,$MPI_LIB,;t t
14757   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
14758   s,@USE_MPI@,$USE_MPI,;t t
14759 < s,@SPRNG_LIB_DIR@,$SPRNG_LIB_DIR,;t t
14760 < s,@SPRNG_INC_DIR@,$SPRNG_INC_DIR,;t t
14761 < s,@SPRNG_LIB@,$SPRNG_LIB,;t t
14762 < s,@USE_SPRNG@,$USE_SPRNG,;t t
14763 < s,@MKL_LIBDIR@,$MKL_LIBDIR,;t t
14764 < s,@MKL_LIB@,$MKL_LIB,;t t
14765 < s,@MKL_INC@,$MKL_INC,;t t
14766 < s,@HAVE_MKL@,$HAVE_MKL,;t t
14759 > s,@USE_CGAL@,$USE_CGAL,;t t
14760 > s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
14761 > s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
14762 > s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
14763 > s,@CGAL_DEFINES@,$CGAL_DEFINES,;t t
14764 > s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
14765 > s,@CGAL_LIBS@,$CGAL_LIBS,;t t
14766 > s,@DOXYGEN@,$DOXYGEN,;t t
14767 > s,@DOT@,$DOT,;t t
14768 > s,@DOC@,$DOC,;t t
14769 > s,@enable_dot@,$enable_dot,;t t
14770 > s,@enable_html_docs@,$enable_html_docs,;t t
14771 > s,@enable_latex_docs@,$enable_latex_docs,;t t
14772   s,@BATEXT@,$BATEXT,;t t
14773   s,@MKINSTALLDIRS@,$MKINSTALLDIRS,;t t
14774   s,@OOPSE@,$OOPSE,;t t
14775   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
14776   s,@SUBDIRS@,$SUBDIRS,;t t
8262 s,@FFLAGS@,$FFLAGS,;t t
14777   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
14778   CEOF
14779  
# Line 8497 | Line 15011 | done
15011      rm -f $tmp/out
15012    fi
15013  
15014 +  # Run the commands associated with the file.
15015 +  case $ac_file in
15016 +    make/Makefile ) chmod 0755 scripts/* ;;
15017 +    src/utils/Makefile ) chmod 0755 scripts/* ;;
15018 +    src/applications/nanoRodBuilder/Makefile ) chmod 0755 scripts/* ;;
15019 +    scripts/filepp ) chmod 0755 scripts/* ;;
15020 +  esac
15021   done
15022   _ACEOF
15023   cat >>$CONFIG_STATUS <<\_ACEOF

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines