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

Comparing trunk/configure (file contents):
Revision 768 by chuckv, Tue Nov 29 22:54:21 2005 UTC vs.
Revision 1141 by chuckv, Wed May 30 18:47:04 2007 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.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_TARNAME='oopse'
269   # Identity of this package.
270   PACKAGE_NAME='OOPSE'
271   PACKAGE_TARNAME='oopse'
272 < PACKAGE_VERSION='2.0'
273 < PACKAGE_STRING='OOPSE 2.0'
272 > PACKAGE_VERSION='3.0'
273 > PACKAGE_STRING='OOPSE 3.0'
274   PACKAGE_BUGREPORT='gezelter@nd.edu'
275  
276   ac_unique_file="src/applications/oopse/oopse.cpp"
# Line 312 | Line 312 | ac_includes_default="\
312   # include <unistd.h>
313   #endif"
314  
315 < ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS PROGNAME debug build build_cpu build_vendor build_os host host_cpu host_vendor host_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX OOPSE_TEMPLATE_FLAGS EXTRA_CC_FLAG F90 F90FLAGS ac_ct_F90 PREPFLAG PREPDEFFLAG F90LIBS F90_FUNC F90_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES CPP EGREP CXXCPP LIBOBJS INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN_S SET_MAKE RANLIB ac_ct_RANLIB YACC LEX LEXLIB LEX_OUTPUT_ROOT PERLINTERP PERL_SHEBANG AR PS 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 FFLAGS LTLIBOBJS'
315 > ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os PROGNAME debug USE_SINGLE_PRECISION CXX CXXFLAGS LDFLAGS CPPFLAGS ac_ct_CXX EXEEXT OBJEXT CC CFLAGS ac_ct_CC FC FCFLAGS ac_ct_FC CPP EGREP LN_S SET_MAKE RANLIB ac_ct_RANLIB PERLINTERP PERL_SHEBANG INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA AR PS FCFLAGS_F90 FCFLAGS_SRCEXT PREPDEFFLAG FCLIBS FC_FUNC FC_FUNC_ MOD F90_WORK_FILES_ARG MODDIRFLAG F90MODINCSPEC F90_MODULE_NAMES ZLIB_INC_DIR ZLIB_LIB_DIR ZLIB FFTW_INC_DIR FFTW_LIB_DIR FFTW_LIBS LIBOBJS POW_LIB CXXCPP __func__ MPI_LIB_DIR MPI_INC_DIR MPI_F90_INC MPI_LIB MPI_F90_LIB USE_MPI 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_cv_env_target_alias_value=$target_alias
753   ac_env_target_alias_value=$target_alias
754   ac_cv_env_target_alias_set=${target_alias+set}
755   ac_cv_env_target_alias_value=$target_alias
756 – ac_env_CC_set=${CC+set}
757 – ac_env_CC_value=$CC
758 – ac_cv_env_CC_set=${CC+set}
759 – ac_cv_env_CC_value=$CC
760 – ac_env_CFLAGS_set=${CFLAGS+set}
761 – ac_env_CFLAGS_value=$CFLAGS
762 – ac_cv_env_CFLAGS_set=${CFLAGS+set}
763 – ac_cv_env_CFLAGS_value=$CFLAGS
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_cv_env_CXXFLAGS_value=$CXXFLAGS
761   ac_env_CXXFLAGS_value=$CXXFLAGS
762   ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763   ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764 < ac_env_F90_set=${F90+set}
765 < ac_env_F90_value=$F90
766 < ac_cv_env_F90_set=${F90+set}
767 < ac_cv_env_F90_value=$F90
768 < ac_env_F90FLAGS_set=${F90FLAGS+set}
769 < ac_env_F90FLAGS_value=$F90FLAGS
770 < ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
771 < ac_cv_env_F90FLAGS_value=$F90FLAGS
764 > ac_env_LDFLAGS_set=${LDFLAGS+set}
765 > ac_env_LDFLAGS_value=$LDFLAGS
766 > ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
767 > ac_cv_env_LDFLAGS_value=$LDFLAGS
768 > ac_env_CPPFLAGS_set=${CPPFLAGS+set}
769 > ac_env_CPPFLAGS_value=$CPPFLAGS
770 > ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771 > ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772 > ac_env_CC_set=${CC+set}
773 > ac_env_CC_value=$CC
774 > ac_cv_env_CC_set=${CC+set}
775 > ac_cv_env_CC_value=$CC
776 > ac_env_CFLAGS_set=${CFLAGS+set}
777 > ac_env_CFLAGS_value=$CFLAGS
778 > ac_cv_env_CFLAGS_set=${CFLAGS+set}
779 > ac_cv_env_CFLAGS_value=$CFLAGS
780 > ac_env_FC_set=${FC+set}
781 > ac_env_FC_value=$FC
782 > ac_cv_env_FC_set=${FC+set}
783 > ac_cv_env_FC_value=$FC
784 > ac_env_FCFLAGS_set=${FCFLAGS+set}
785 > ac_env_FCFLAGS_value=$FCFLAGS
786 > ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787 > ac_cv_env_FCFLAGS_value=$FCFLAGS
788   ac_env_CPP_set=${CPP+set}
789   ac_env_CPP_value=$CPP
790   ac_cv_env_CPP_set=${CPP+set}
# Line 801 | 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 862 | Line 862 | if test -n "$ac_init_help"; then
862  
863   if test -n "$ac_init_help"; then
864    case $ac_init_help in
865 <     short | recursive ) echo "Configuration of OOPSE 2.0:";;
865 >     short | recursive ) echo "Configuration of OOPSE 3.0:";;
866     esac
867    cat <<\_ACEOF
868  
869   Optional Features:
870    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
871    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
872 +  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
873    --enable-debug          Compile OOPSE in debug mode
874 +  --enable-single         compile OOPSE in single precision
875 +  --enable-float          synonym for --enable-single
876    --enable-doxygen        enable documentation generation with doxygen (auto)
877    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
878    --enable-html-docs      enable HTML generation with doxygen (yes)
879    --enable-latex-docs     enable LaTeX documentation generation with doxygen (no)
877 –  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
880  
881   Optional Packages:
882    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
883    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
882 –  --with-zlib=DIR root directory path of zlib installation defaults to
883 –                    /usr/local or /usr if not found in /usr/local
884 –  --without-zlib to disable zlib usage completely
884    --with-perl-shebang     override what perl thinks is the way for the kernel
885                            to start it (seldom needed)
886 +  --with-zlib=DIR         root directory path of zlib installation (defaults
887 +                          to /usr/local or /usr if not found in /usr/local)
888 +  --with-fftw=DIR         root directory path of fftw installation (defaults
889 +                          to /usr/local or /usr if not found in /usr/local)
890    --with-mpi=<prefix>     compile with MPI installed in <prefix> [default=no]
888 –  --with-cgal-makefile=FILE  CGAL makefile that should be used
891  
892   Some influential environment variables:
893 <  CC          C compiler command
894 <  CFLAGS      C compiler flags
893 >  CXX         C++ compiler command
894 >  CXXFLAGS    C++ compiler flags
895    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
896                nonstandard directory <lib dir>
897    CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
898                headers in a nonstandard directory <include dir>
899 <  CXX         C++ compiler command
900 <  CXXFLAGS    C++ compiler flags
901 <  F90         Fortran 90 compiler command
902 <  F90FLAGS    Fortran 90 compiler flags
899 >  CC          C compiler command
900 >  CFLAGS      C compiler flags
901 >  FC          Fortran compiler command
902 >  FCFLAGS     Fortran compiler flags
903    CPP         C preprocessor
904    CXXCPP      C++ preprocessor
905  
# Line 993 | Line 995 | esac
995      else
996        echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
997      fi
998 <    cd "$ac_popdir"
998 >    cd $ac_popdir
999    done
1000   fi
1001  
1002   test -n "$ac_init_help" && exit 0
1003   if $ac_init_version; then
1004    cat <<\_ACEOF
1005 < OOPSE configure 2.0
1005 > OOPSE configure 3.0
1006   generated by GNU Autoconf 2.59
1007  
1008   Copyright (C) 2003 Free Software Foundation, Inc.
# Line 1014 | Line 1016 | running configure, to aid debugging if configure makes
1016   This file contains any messages produced by compilers while
1017   running configure, to aid debugging if configure makes a mistake.
1018  
1019 < It was created by OOPSE $as_me 2.0, which was
1019 > It was created by OOPSE $as_me 3.0, which was
1020   generated by GNU Autoconf 2.59.  Invocation command line was
1021  
1022    $ $0 $@
# Line 1376 | Line 1378 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1378   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1379  
1380  
1381 < # This file is part of Autoconf.                       -*- Autoconf -*-
1380 < # Programming languages support.
1381 < # Copyright 2000, 2001
1382 < # Free Software Foundation, Inc.
1383 < #
1384 < # This program is free software; you can redistribute it and/or modify
1385 < # it under the terms of the GNU General Public License as published by
1386 < # the Free Software Foundation; either version 2, or (at your option)
1387 < # any later version.
1388 < #
1389 < # This program is distributed in the hope that it will be useful,
1390 < # but WITHOUT ANY WARRANTY; without even the implied warranty of
1391 < # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1392 < # GNU General Public License for more details.
1393 < #
1394 < # You should have received a copy of the GNU General Public License
1395 < # along with this program; if not, write to the Free Software
1396 < # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1397 < # 02111-1307, USA.
1398 < #
1399 < # As a special exception, the Free Software Foundation gives unlimited
1400 < # permission to copy, distribute and modify the configure scripts that
1401 < # are the output of Autoconf.  You need not follow the terms of the GNU
1402 < # General Public License when using or distributing such scripts, even
1403 < # though portions of the text of Autoconf appear in them.  The GNU
1404 < # General Public License (GPL) does govern all other use of the material
1405 < # that constitutes the Autoconf program.
1406 < #
1407 < # Certain portions of the Autoconf source text are designed to be copied
1408 < # (in certain cases, depending on the input) into the output of
1409 < # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
1410 < # source text consists of comments plus executable code that decides which
1411 < # of the data portions to output in any given case.  We call these
1412 < # comments and executable code the "non-data" portions.  Autoconf never
1413 < # copies any of the non-data portions into its output.
1414 < #
1415 < # This special exception to the GPL applies to versions of Autoconf
1416 < # released by the Free Software Foundation.  When you make and
1417 < # distribute a modified version of Autoconf, you may extend this special
1418 < # exception to the GPL to apply to your modified version as well, *unless*
1419 < # your modified version has the potential to copy into its output some
1420 < # of the text that was the non-data portion of the version that you started
1421 < # with.  (In other words, unless your change moves or copies text from
1422 < # the non-data portions to the data portions.)  If your modification has
1423 < # such potential, you must delete any notice of this special exception
1424 < # to the GPL from your modified version.
1425 < #
1426 < # Written by Akim Demaille, Christian Marquardt, Martin Wilks (and probably
1427 < # many others).
1381 >          ac_config_headers="$ac_config_headers src/config.h"
1382  
1383  
1430 – # Table of Contents:
1431 – #
1432 – # 1. Language selection
1433 – #    and routines to produce programs in a given language.
1434 – #  a. Fortran 77 (to be moved from aclang.m4)
1435 – #  b. Fortran 90
1436 – #  c. Fortran 95
1437 – #
1438 – # 2. Producing programs in a given language.
1439 – #  a. Fortran 77 (to be moved from aclang.m4)
1440 – #  b. Fortran 90
1441 – #  c. Fortran 95
1442 – #
1443 – # 3. Looking for a compiler
1444 – #    And possibly the associated preprocessor.
1445 – #  a. Fortran 77 (to be moved from aclang.m4)
1446 – #  b. Fortran 90
1447 – #  c. Fortran 95
1448 – #
1449 – # 4. Compilers' characteristics.
1450 – #  a. Fortran 77 (to be moved from aclang.m4)
1451 – #  b. Fortran 90
1452 – #  c. Fortran 95
1384  
1454 – # _AC_LIST_MEMBER_IF(ELEMENT, LIST, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
1455 – # ---------------------------------------------------------------------------
1456 – #
1457 – # Processing the elements of a list is tedious in shell programming,
1458 – # as lists tend to be implemented as space delimited strings.
1459 – #
1460 – # This macro searches LIST for ELEMENT, and executes ACTION-IF-FOUND
1461 – # if ELEMENT is a member of LIST, otherwise it executes
1462 – # ACTION-IF-NOT-FOUND.
1463 – # _AC_LIST_MEMBER_IF
1385  
1386  
1387  
1467 – # _AC_LINKER_OPTION(LINKER-OPTIONS, SHELL-VARIABLE)
1468 – # -------------------------------------------------
1469 – #
1470 – # Specifying options to the compiler (whether it be the C, C++ or
1471 – # Fortran 77 compiler) that are meant for the linker is compiler
1472 – # dependent.  This macro lets you give options to the compiler that
1473 – # are meant for the linker in a portable, compiler-independent way.
1474 – #
1475 – # This macro take two arguments, a list of linker options that the
1476 – # compiler should pass to the linker (LINKER-OPTIONS) and the name of
1477 – # a shell variable (SHELL-VARIABLE).  The list of linker options are
1478 – # appended to the shell variable in a compiler-dependent way.
1479 – #
1480 – # For example, if the selected language is C, then this:
1481 – #
1482 – #   _AC_LINKER_OPTION([-R /usr/local/lib/foo], foo_LDFLAGS)
1483 – #
1484 – # will expand into this if the selected C compiler is gcc:
1485 – #
1486 – #   foo_LDFLAGS="-Xlinker -R -Xlinker /usr/local/lib/foo"
1487 – #
1488 – # otherwise, it will expand into this:
1489 – #
1490 – #   foo_LDFLAGS"-R /usr/local/lib/foo"
1491 – #
1492 – # You are encouraged to add support for compilers that this macro
1493 – # doesn't currently support.
1494 – # FIXME: Get rid of this macro.
1495 – # _AC_LINKER_OPTION
1388  
1389  
1390  
1499 – ## ----------------------- ##
1500 – ## 1. Language selection.  ##
1501 – ## ----------------------- ##
1391  
1503 – # ----------------------------- #
1504 – # 1b. The Fortran 90 language.  #
1505 – # ----------------------------- #
1392  
1507 – # AC_LANG(Fortran 90)
1508 – # -------------------
1393  
1394  
1395  
1512 – # _AC_LANG_ABBREV(Fortran 90)
1513 – # ---------------------------
1396  
1397  
1398  
1517 – # ----------------------------- #
1518 – # 1c. The Fortran 95 language.  #
1519 – # ----------------------------- #
1399  
1521 – # AC_LANG(Fortran 95)
1522 – # -------------------
1400  
1401  
1402  
1526 – # _AC_LANG_ABBREV(Fortran 95)
1527 – # ---------------------------
1403  
1404  
1405  
1531 – ## ---------------------- ##
1532 – ## 2.Producing programs.  ##
1533 – ## ---------------------- ##
1406  
1535 – # ------------------------ #
1536 – # 2b. Fortran 90 sources.  #
1537 – # ------------------------ #
1407  
1539 – # AC_LANG_SOURCE(Fortran 90)(BODY)
1540 – # --------------------------------
1408  
1409  
1410  
1544 – # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1545 – # -----------------------------------------------
1411  
1412  
1548 – # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1549 – # --------------------------------------------
1413  
1414  
1415  
1553 – # ------------------------ #
1554 – # 2c. Fortran 95 sources.  #
1555 – # ------------------------ #
1416  
1557 – # AC_LANG_SOURCE(Fortran 95)(BODY)
1558 – # --------------------------------
1417  
1418  
1561 – # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1562 – # -----------------------------------------------
1419  
1420  
1565 – # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1566 – # --------------------------------------------
1421  
1422  
1423  
1570 – ## -------------------------------------------- ##
1571 – ## 3. Looking for Compilers and Preprocessors.  ##
1572 – ## -------------------------------------------- ##
1424  
1574 – # ----------------------------- #
1575 – # 3b. The Fortran 90 compiler.  #
1576 – # ----------------------------- #
1425  
1578 –
1579 – # AC_LANG_PREPROC(Fortran 90)
1580 – # ---------------------------
1581 – # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1582 –
1583 –
1584 –
1585 – # AC_LANG_COMPILER(Fortran 90)
1586 – # ----------------------------
1587 – # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1588 – # AC_REQUIRE'able.
1589 –
1590 –
1591 –
1592 – # AC_PROG_F90([COMPILERS...])
1593 – # ---------------------------
1594 – # COMPILERS is a space separated list of Fortran 90 compilers to search
1595 – # for.
1426   #
1597 – # Compilers are ordered by
1598 – #  1. F90, F95
1599 – #  2. Good/tested native compilers, bad/untested native compilers
1427   #
1601 – # pgf90 is the Portland Group F90 compilers.
1602 – # xlf90/xlf95 are IBM (AIX) F90/F95 compilers.
1603 – # lf95 is the Lahey-Fujitsu compiler.
1604 – # epcf90 is the "Edinburgh Portable Compiler" F90.
1605 – # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1606 – # AC_PROG_F90
1607 –
1608 –
1609 – # ----------------------------- #
1610 – # 3c. The Fortran 95 compiler.  #
1611 – # ----------------------------- #
1612 –
1613 –
1614 – # AC_LANG_PREPROC(Fortran 95)
1615 – # ---------------------------
1616 – # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1617 –
1618 –
1619 –
1620 – # AC_LANG_COMPILER(Fortran 95)
1621 – # ----------------------------
1622 – # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1623 – # AC_REQUIRE'able.
1624 –
1625 –
1626 –
1627 – # AC_PROG_F95([COMPILERS...])
1628 – # ---------------------------
1629 – # COMPILERS is a space separated list of Fortran 95 compilers to search
1630 – # for.
1428   #
1632 – # Compilers are ordered by
1633 – #  1. Good/tested native compilers, bad/untested native compilers
1634 – #
1635 – # xlf95 is the IBM (AIX) F95 compiler.
1636 – # lf95 is the Lahey-Fujitsu compiler.
1637 – # fort is the Compaq Fortran 90 (now 95) compiler for Tru64 and Linux/Alpha.
1638 – # AC_PROG_F95
1429  
1430  
1641 – ## ------------------------------- ##
1642 – ## 4. Compilers' characteristics.  ##
1643 – ## ------------------------------- ##
1431  
1432  
1646 – # ---------------------------------------- #
1647 – # 4b. Fortan 90 compiler characteristics.  #
1648 – # ---------------------------------------- #
1433  
1434  
1435 < # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1436 < # -------------------------------------------------
1653 < # Link a trivial Fortran program, compiling with a verbose output FLAG
1654 < # (which default value, $ac_cv_prog_f90_v, is computed by
1655 < # _AC_PROG_F90_V), and return the output in $ac_f90_v_output.  This
1656 < # output is processed in the way expected by AC_F90_LIBRARY_LDFLAGS,
1657 < # so that any link flags that are echoed by the compiler appear as
1658 < # space-separated items.
1659 < # _AC_PROG_F90_V_OUTPUT
1660 <
1661 <
1662 < # _AC_PROG_F90_V
1663 < # --------------
1435 > # AC_F90_MODULE_NAMES
1436 > # -------------------
1437   #
1438 < # Determine the flag that causes the Fortran 90 compiler to print
1666 < # information of library and object files (normally -v)
1667 < # Needed for AC_F90_LIBRARY_FLAGS
1668 < # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1669 < # _AC_PROG_F90_V
1670 <
1671 <
1672 < # AC_F90_LIBRARY_LDFLAGS
1673 < # ----------------------
1438 > # Figure out how the Fortran 90 compiler constructs module file names
1439   #
1440 < # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 90
1676 < # intrinsic and run-time libraries that are required to successfully
1677 < # link a Fortran 90 program or shared library.  The output variable
1678 < # F90LIBS is set to these flags.
1679 < #
1680 < # This macro is intended to be used in those situations when it is
1681 < # necessary to mix, e.g. C++ and Fortran 90, source code into a single
1682 < # program or shared library.
1683 < #
1684 < # For example, if object files from a C++ and Fortran 90 compiler must
1685 < # be linked together, then the C++ compiler/linker must be used for
1686 < # linking (since special C++-ish things need to happen at link time
1687 < # like calling global constructors, instantiating templates, enabling
1688 < # exception support, etc.).
1689 < #
1690 < # However, the Fortran 90 intrinsic and run-time libraries must be
1691 < # linked in as well, but the C++ compiler/linker doesn't know how to
1692 < # add these Fortran 90 libraries.  Hence, the macro
1693 < # "AC_F90_LIBRARY_LDFLAGS" was created to determine these Fortran 90
1694 < # libraries.
1695 < #
1696 < # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1697 < # AC_F90_LIBRARY_LDFLAGS
1440 > # AC_F90_MODULE_NAMES
1441  
1442  
1700 – # _AC_F90_NAME_MANGLING
1701 – # ---------------------
1702 – # Test for the name mangling scheme used by the Fortran 90 compiler.
1703 – #
1704 – # Sets ac_cv_f90_mangling. The value contains three fields, separated
1705 – # by commas:
1706 – #
1707 – # lower case / upper case:
1708 – #    case translation of the Fortan 90 symbols
1709 – # underscore / no underscore:
1710 – #    whether the compiler appends "_" to symbol names
1711 – # extra underscore / no extra underscore:
1712 – #    whether the compiler appends an extra "_" to symbol names already
1713 – #    containing at least one underscore
1714 – #
1715 – # _AC_F90_NAME_MANGLING
1443  
1717 – # The replacement is empty.
1444  
1445  
1446  
1721 – # AC_F90_WRAPPERS
1722 – # ---------------
1723 – # Defines C macros F90_FUNC(name,NAME) and F90_FUNC_(name,NAME) to
1724 – # properly mangle the names of C identifiers, and C identifiers with
1725 – # underscores, respectively, so that they match the name mangling
1726 – # scheme used by the Fortran 90 compiler.
1727 – # AC_F90_WRAPPERS
1447  
1448  
1730 – # AC_F90_FUNC(NAME, [SHELLVAR = NAME])
1731 – # ------------------------------------
1732 – # For a Fortran subroutine of given NAME, define a shell variable
1733 – # $SHELLVAR to the Fortran 90 mangled name.  If the SHELLVAR
1734 – # argument is not supplied, it defaults to NAME.
1735 – # AC_F90_FUNC
1449  
1450  
1738 – # ---------------------------------------- #
1739 – # 4c. Fortan 95 compiler characteristics.  #
1740 – # ---------------------------------------- #
1451  
1452  
1743 – # _AC_PROG_F95_V_OUTPUT([FLAG = $ac_cv_prog_f95_v])
1744 – # -------------------------------------------------
1745 – # Link a trivial Fortran program, compiling with a verbose output FLAG
1746 – # (which default value, $ac_cv_prog_f95_v, is computed by
1747 – # _AC_PROG_F95_V), and return the output in $ac_f95_v_output.  This
1748 – # output is processed in the way expected by AC_F95_LIBRARY_LDFLAGS,
1749 – # so that any link flags that are echoed by the compiler appear as
1750 – # space-separated items.
1751 – # _AC_PROG_F95_V_OUTPUT
1453  
1454  
1754 – # _AC_PROG_F95_V
1755 – # --------------
1756 – #
1757 – # Determine the flag that causes the Fortran 95 compiler to print
1758 – # information of library and object files (normally -v)
1759 – # Needed for AC_F95_LIBRARY_FLAGS
1760 – # Some compilers don't accept -v (Lahey: -verbose, xlf: -V, Fujitsu: -###)
1761 – # _AC_PROG_F95_V
1455  
1456  
1764 – # AC_F95_LIBRARY_LDFLAGS
1765 – # ----------------------
1766 – #
1767 – # Determine the linker flags (e.g. "-L" and "-l") for the Fortran 95
1768 – # intrinsic and run-time libraries that are required to successfully
1769 – # link a Fortran 95 program or shared library.  The output variable
1770 – # F95LIBS is set to these flags.
1771 – #
1772 – # This macro is intended to be used in those situations when it is
1773 – # necessary to mix, e.g. C++ and Fortran 95, source code into a single
1774 – # program or shared library.
1775 – #
1776 – # For example, if object files from a C++ and Fortran 95 compiler must
1777 – # be linked together, then the C++ compiler/linker must be used for
1778 – # linking (since special C++-ish things need to happen at link time
1779 – # like calling global constructors, instantiating templates, enabling
1780 – # exception support, etc.).
1781 – #
1782 – # However, the Fortran 95 intrinsic and run-time libraries must be
1783 – # linked in as well, but the C++ compiler/linker doesn't know how to
1784 – # add these Fortran 95 libraries.  Hence, the macro
1785 – # "AC_F95_LIBRARY_LDFLAGS" was created to determine these Fortran 95
1786 – # libraries.
1787 – #
1788 – # This macro was copied from the Fortran 77 version by Matthew D. Langston.
1789 – # AC_F95_LIBRARY_LDFLAGS
1457  
1458  
1792 – # _AC_F95_NAME_MANGLING
1793 – # ---------------------
1794 – # Test for the name mangling scheme used by the Fortran 95 compiler.
1795 – #
1796 – # Sets ac_cv_f95_mangling. The value contains three fields, separated
1797 – # by commas:
1798 – #
1799 – # lower case / upper case:
1800 – #    case translation of the Fortan 95 symbols
1801 – # underscore / no underscore:
1802 – #    whether the compiler appends "_" to symbol names
1803 – # extra underscore / no extra underscore:
1804 – #    whether the compiler appends an extra "_" to symbol names already
1805 – #    containing at least one underscore
1806 – #
1807 – # _AC_F95_NAME_MANGLING
1459  
1809 – # The replacement is empty.
1460  
1461  
1462  
1813 – # AC_F95_WRAPPERS
1814 – # ---------------
1815 – # Defines C macros F95_FUNC(name,NAME) and F95_FUNC_(name,NAME) to
1816 – # properly mangle the names of C identifiers, and C identifiers with
1817 – # underscores, respectively, so that they match the name mangling
1818 – # scheme used by the Fortran 95 compiler.
1819 – # AC_F95_WRAPPERS
1463  
1464  
1822 – # AC_F95_FUNC(NAME, [SHELLVAR = NAME])
1823 – # ------------------------------------
1824 – # For a Fortran subroutine of given NAME, define a shell variable
1825 – # $SHELLVAR to the Fortran 95 mangled name.  If the SHELLVAR
1826 – # argument is not supplied, it defaults to NAME.
1827 – # AC_F95_FUNC
1465  
1829 – # AC_F90_MODULE_NAMES
1830 – # -------------------
1831 – #
1832 – # Figure out how the Fortran 90 compiler constructs module file names
1833 – #
1834 – # AC_F90_MODULE_NAMES
1466  
1467  
1468  
# Line 1885 | Line 1516 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1516  
1517  
1518  
1888 – #
1889 – #
1890 – #
1519  
1520  
1521  
# Line 1896 | Line 1524 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1524  
1525  
1526  
1899 – # set program name
1900 – PROGNAME="oopse"
1527  
1528  
1903 – # there are two ways to do debugging.  One with the --enable-debug flag
1904 – # and one using the DEBUG environment variable
1905 –
1906 – debug=0
1907 – # Check whether --enable-debug or --disable-debug was given.
1908 – if test "${enable_debug+set}" = set; then
1909 –  enableval="$enable_debug"
1910 –  debug=1
1911 – fi;
1912 – if test "${DEBUG}"; then
1913 –
1914 – cat >>confdefs.h <<\_ACEOF
1915 – #define debug 1
1916 – _ACEOF
1917 –
1918 –  msg="$msg, debug mode"
1919 – fi
1920 –
1921 –
1529   # who am i
1530   # Make sure we can run config.sub.
1531   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 1977 | Line 1584 | host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\
1584  
1585  
1586  
1587 < ac_ext=c
1588 < ac_cpp='$CPP $CPPFLAGS'
1589 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1590 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1591 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
1587 > # set program name
1588 > PROGNAME="oopse"
1589 >
1590 >
1591 >
1592 >
1593 > OBJEXT=".$OBJEXT"
1594 >
1595 > OOPSE=oopse
1596 >
1597 > if test "x${prefix}" = "xNONE"
1598 > then
1599 >  OOPSE_HOME=${ac_default_prefix}/oopse
1600 > else
1601 >  OOPSE_HOME=${prefix}/oopse
1602 > fi
1603 > # Check whether --enable-oopse-home or --disable-oopse-home was given.
1604 > if test "${enable_oopse_home+set}" = set; then
1605 >  enableval="$enable_oopse_home"
1606 >  OOPSE_HOME="${enableval}"
1607 > fi;
1608 >
1609 > # there are two ways to do debugging.  One with the --enable-debug flag
1610 > # and one using the DEBUG environment variable
1611 >
1612 > debug=0
1613 > # Check whether --enable-debug or --disable-debug was given.
1614 > if test "${enable_debug+set}" = set; then
1615 >  enableval="$enable_debug"
1616 >  debug=1
1617 > fi;
1618 > if test "${DEBUG}"; then
1619 >
1620 > cat >>confdefs.h <<\_ACEOF
1621 > #define debug 1
1622 > _ACEOF
1623 >
1624 >  msg="$msg, debug mode"
1625 > fi
1626 >
1627 >
1628 > # Check whether --enable-single or --disable-single was given.
1629 > if test "${enable_single+set}" = set; then
1630 >  enableval="$enable_single"
1631 >  ok=$enableval
1632 > else
1633 >  ok=no
1634 > fi;
1635 > # Check whether --enable-float or --disable-float was given.
1636 > if test "${enable_float+set}" = set; then
1637 >  enableval="$enable_float"
1638 >  ok=$enableval
1639 > fi;
1640 > if test "$ok" = "yes"; then
1641 >
1642 > cat >>confdefs.h <<\_ACEOF
1643 > #define SINGLE_PRECISION 1
1644 > _ACEOF
1645 >
1646 >        USE_SINGLE_PRECISION=yes
1647 >
1648 > fi
1649 >
1650 > # Checks for programs.
1651 > ac_ext=cc
1652 > ac_cpp='$CXXCPP $CPPFLAGS'
1653 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1654 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1655 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
1656   if test -n "$ac_tool_prefix"; then
1657 <  for ac_prog in icc xlc gcc cc
1657 >  for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1658    do
1659      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
1660   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
1661   echo "$as_me:$LINENO: checking for $ac_word" >&5
1662   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1663 < if test "${ac_cv_prog_CC+set}" = set; then
1663 > if test "${ac_cv_prog_CXX+set}" = set; then
1664    echo $ECHO_N "(cached) $ECHO_C" >&6
1665   else
1666 <  if test -n "$CC"; then
1667 <  ac_cv_prog_CC="$CC" # Let the user override the test.
1666 >  if test -n "$CXX"; then
1667 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
1668   else
1669   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1670   for as_dir in $PATH
# Line 2002 | Line 1673 | do
1673    test -z "$as_dir" && as_dir=.
1674    for ac_exec_ext in '' $ac_executable_extensions; do
1675    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1676 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
1676 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
1677      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1678      break 2
1679    fi
# Line 2011 | Line 1682 | fi
1682  
1683   fi
1684   fi
1685 < CC=$ac_cv_prog_CC
1686 < if test -n "$CC"; then
1687 <  echo "$as_me:$LINENO: result: $CC" >&5
1688 < echo "${ECHO_T}$CC" >&6
1685 > CXX=$ac_cv_prog_CXX
1686 > if test -n "$CXX"; then
1687 >  echo "$as_me:$LINENO: result: $CXX" >&5
1688 > echo "${ECHO_T}$CXX" >&6
1689   else
1690    echo "$as_me:$LINENO: result: no" >&5
1691   echo "${ECHO_T}no" >&6
1692   fi
1693  
1694 <    test -n "$CC" && break
1694 >    test -n "$CXX" && break
1695    done
1696   fi
1697 < if test -z "$CC"; then
1698 <  ac_ct_CC=$CC
1699 <  for ac_prog in icc xlc gcc cc
1697 > if test -z "$CXX"; then
1698 >  ac_ct_CXX=$CXX
1699 >  for ac_prog in $CCC mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
1700   do
1701    # Extract the first word of "$ac_prog", so it can be a program name with args.
1702   set dummy $ac_prog; ac_word=$2
1703   echo "$as_me:$LINENO: checking for $ac_word" >&5
1704   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
1705 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
1705 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
1706    echo $ECHO_N "(cached) $ECHO_C" >&6
1707   else
1708 <  if test -n "$ac_ct_CC"; then
1709 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
1708 >  if test -n "$ac_ct_CXX"; then
1709 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
1710   else
1711   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1712   for as_dir in $PATH
# Line 2044 | Line 1715 | do
1715    test -z "$as_dir" && as_dir=.
1716    for ac_exec_ext in '' $ac_executable_extensions; do
1717    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
1718 <    ac_cv_prog_ac_ct_CC="$ac_prog"
1718 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
1719      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
1720      break 2
1721    fi
# Line 2053 | Line 1724 | fi
1724  
1725   fi
1726   fi
1727 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
1728 < if test -n "$ac_ct_CC"; then
1729 <  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
1730 < echo "${ECHO_T}$ac_ct_CC" >&6
1727 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
1728 > if test -n "$ac_ct_CXX"; then
1729 >  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
1730 > echo "${ECHO_T}$ac_ct_CXX" >&6
1731   else
1732    echo "$as_me:$LINENO: result: no" >&5
1733   echo "${ECHO_T}no" >&6
1734   fi
1735  
1736 <  test -n "$ac_ct_CC" && break
1736 >  test -n "$ac_ct_CXX" && break
1737   done
1738 + test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
1739  
1740 <  CC=$ac_ct_CC
1740 >  CXX=$ac_ct_CXX
1741   fi
1742  
1743  
2072 – test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2073 – See \`config.log' for more details." >&5
2074 – echo "$as_me: error: no acceptable C compiler found in \$PATH
2075 – See \`config.log' for more details." >&2;}
2076 –   { (exit 1); exit 1; }; }
2077 –
1744   # Provide some information about the compiler.
1745   echo "$as_me:$LINENO:" \
1746 <     "checking for C compiler version" >&5
1746 >     "checking for C++ compiler version" >&5
1747   ac_compiler=`set X $ac_compile; echo $2`
1748   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
1749    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2115 | Line 1781 | ac_clean_files="$ac_clean_files a.out a.exe b.out"
1781   # Try to create an executable without -o first, disregard a.out.
1782   # It will help us diagnose broken compilers, and finding out an intuition
1783   # of exeext.
1784 < echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
1785 < echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
1784 > echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
1785 > echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6
1786   ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
1787   if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
1788    (eval $ac_link_default) 2>&5
# Line 2159 | Line 1825 | sed 's/^/| /' conftest.$ac_ext >&5
1825    echo "$as_me: failed program was:" >&5
1826   sed 's/^/| /' conftest.$ac_ext >&5
1827  
1828 < { { echo "$as_me:$LINENO: error: C compiler cannot create executables
1828 > { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
1829   See \`config.log' for more details." >&5
1830 < echo "$as_me: error: C compiler cannot create executables
1830 > echo "$as_me: error: C++ compiler cannot create executables
1831   See \`config.log' for more details." >&2;}
1832     { (exit 77); exit 77; }; }
1833   fi
# Line 2172 | Line 1838 | echo "${ECHO_T}$ac_file" >&6
1838  
1839   # Check the compiler produces executables we can run.  If not, either
1840   # the compiler is broken, or we cross compile.
1841 < echo "$as_me:$LINENO: checking whether the C compiler works" >&5
1842 < echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
1841 > echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
1842 > echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6
1843   # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
1844   # If not cross compiling, check that we can run a simple program.
1845   if test "$cross_compiling" != yes; then
# Line 2188 | Line 1854 | if test "$cross_compiling" != yes; then
1854      if test "$cross_compiling" = maybe; then
1855          cross_compiling=yes
1856      else
1857 <        { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
1857 >        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
1858   If you meant to cross compile, use \`--host'.
1859   See \`config.log' for more details." >&5
1860 < echo "$as_me: error: cannot run C compiled programs.
1860 > echo "$as_me: error: cannot run C++ compiled programs.
1861   If you meant to cross compile, use \`--host'.
1862   See \`config.log' for more details." >&2;}
1863     { (exit 1); exit 1; }; }
# Line 2296 | Line 1962 | ac_objext=$OBJEXT
1962   echo "${ECHO_T}$ac_cv_objext" >&6
1963   OBJEXT=$ac_cv_objext
1964   ac_objext=$OBJEXT
1965 < echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
1966 < echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
1967 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
1965 > echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
1966 > echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
1967 > if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
1968    echo $ECHO_N "(cached) $ECHO_C" >&6
1969   else
1970    cat >conftest.$ac_ext <<_ACEOF
# Line 2328 | Line 1994 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
1994    cat conftest.err >&5
1995    echo "$as_me:$LINENO: \$? = $ac_status" >&5
1996    (exit $ac_status); } &&
1997 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
1997 >         { ac_try='test -z "$ac_cxx_werror_flag"
1998 >                         || test ! -s conftest.err'
1999    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2000    (eval $ac_try) 2>&5
2001    ac_status=$?
# Line 2348 | Line 2015 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2015   ac_compiler_gnu=no
2016   fi
2017   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2018 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
2018 > ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2019  
2020   fi
2021 < echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2022 < echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2023 < GCC=`test $ac_compiler_gnu = yes && echo yes`
2024 < ac_test_CFLAGS=${CFLAGS+set}
2025 < ac_save_CFLAGS=$CFLAGS
2026 < CFLAGS="-g"
2027 < echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2028 < echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2029 < if test "${ac_cv_prog_cc_g+set}" = set; then
2021 > echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2022 > echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2023 > GXX=`test $ac_compiler_gnu = yes && echo yes`
2024 > ac_test_CXXFLAGS=${CXXFLAGS+set}
2025 > ac_save_CXXFLAGS=$CXXFLAGS
2026 > CXXFLAGS="-g"
2027 > echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2028 > echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2029 > if test "${ac_cv_prog_cxx_g+set}" = set; then
2030    echo $ECHO_N "(cached) $ECHO_C" >&6
2031   else
2032    cat >conftest.$ac_ext <<_ACEOF
# Line 2386 | Line 2053 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2053    cat conftest.err >&5
2054    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2055    (exit $ac_status); } &&
2056 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2056 >         { ac_try='test -z "$ac_cxx_werror_flag"
2057 >                         || test ! -s conftest.err'
2058    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2059    (eval $ac_try) 2>&5
2060    ac_status=$?
# Line 2398 | Line 2066 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2066    ac_status=$?
2067    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2068    (exit $ac_status); }; }; then
2069 <  ac_cv_prog_cc_g=yes
2069 >  ac_cv_prog_cxx_g=yes
2070   else
2071    echo "$as_me: failed program was:" >&5
2072   sed 's/^/| /' conftest.$ac_ext >&5
2073  
2074 < ac_cv_prog_cc_g=no
2074 > ac_cv_prog_cxx_g=no
2075   fi
2076   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2077   fi
2078 < echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2079 < echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2080 < if test "$ac_test_CFLAGS" = set; then
2081 <  CFLAGS=$ac_save_CFLAGS
2082 < elif test $ac_cv_prog_cc_g = yes; then
2083 <  if test "$GCC" = yes; then
2084 <    CFLAGS="-g -O2"
2078 > echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2079 > echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2080 > if test "$ac_test_CXXFLAGS" = set; then
2081 >  CXXFLAGS=$ac_save_CXXFLAGS
2082 > elif test $ac_cv_prog_cxx_g = yes; then
2083 >  if test "$GXX" = yes; then
2084 >    CXXFLAGS="-g -O2"
2085    else
2086 <    CFLAGS="-g"
2086 >    CXXFLAGS="-g"
2087    fi
2088   else
2089 <  if test "$GCC" = yes; then
2090 <    CFLAGS="-O2"
2089 >  if test "$GXX" = yes; then
2090 >    CXXFLAGS="-O2"
2091    else
2092 <    CFLAGS=
2092 >    CXXFLAGS=
2093    fi
2094   fi
2095 < echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2428 < echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2429 < if test "${ac_cv_prog_cc_stdc+set}" = set; then
2430 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2431 < else
2432 <  ac_cv_prog_cc_stdc=no
2433 < ac_save_CC=$CC
2434 < cat >conftest.$ac_ext <<_ACEOF
2435 < /* confdefs.h.  */
2436 < _ACEOF
2437 < cat confdefs.h >>conftest.$ac_ext
2438 < cat >>conftest.$ac_ext <<_ACEOF
2439 < /* end confdefs.h.  */
2440 < #include <stdarg.h>
2441 < #include <stdio.h>
2442 < #include <sys/types.h>
2443 < #include <sys/stat.h>
2444 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2445 < struct buf { int x; };
2446 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
2447 < static char *e (p, i)
2448 <     char **p;
2449 <     int i;
2450 < {
2451 <  return p[i];
2452 < }
2453 < static char *f (char * (*g) (char **, int), char **p, ...)
2454 < {
2455 <  char *s;
2456 <  va_list v;
2457 <  va_start (v,p);
2458 <  s = g (p, va_arg (v,int));
2459 <  va_end (v);
2460 <  return s;
2461 < }
2462 <
2463 < /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2464 <   function prototypes and stuff, but not '\xHH' hex character constants.
2465 <   These don't provoke an error unfortunately, instead are silently treated
2466 <   as 'x'.  The following induces an error, until -std1 is added to get
2467 <   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2468 <   array size at least.  It's necessary to write '\x00'==0 to get something
2469 <   that's true only with -std1.  */
2470 < int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2471 <
2472 < int test (int i, double x);
2473 < struct s1 {int (*f) (int a);};
2474 < struct s2 {int (*f) (double a);};
2475 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2476 < int argc;
2477 < char **argv;
2478 < int
2479 < main ()
2480 < {
2481 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2482 <  ;
2483 <  return 0;
2484 < }
2485 < _ACEOF
2486 < # Don't try gcc -ansi; that turns off useful extensions and
2487 < # breaks some systems' header files.
2488 < # AIX                   -qlanglvl=ansi
2489 < # Ultrix and OSF/1      -std1
2490 < # HP-UX 10.20 and later -Ae
2491 < # HP-UX older versions  -Aa -D_HPUX_SOURCE
2492 < # SVR4                  -Xc -D__EXTENSIONS__
2493 < for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2494 < do
2495 <  CC="$ac_save_CC $ac_arg"
2496 <  rm -f conftest.$ac_objext
2497 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2498 <  (eval $ac_compile) 2>conftest.er1
2499 <  ac_status=$?
2500 <  grep -v '^ *+' conftest.er1 >conftest.err
2501 <  rm -f conftest.er1
2502 <  cat conftest.err >&5
2503 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2504 <  (exit $ac_status); } &&
2505 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2506 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2507 <  (eval $ac_try) 2>&5
2508 <  ac_status=$?
2509 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2510 <  (exit $ac_status); }; } &&
2511 <         { ac_try='test -s conftest.$ac_objext'
2512 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2513 <  (eval $ac_try) 2>&5
2514 <  ac_status=$?
2515 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2516 <  (exit $ac_status); }; }; then
2517 <  ac_cv_prog_cc_stdc=$ac_arg
2518 < break
2519 < else
2520 <  echo "$as_me: failed program was:" >&5
2521 < sed 's/^/| /' conftest.$ac_ext >&5
2522 <
2523 < fi
2524 < rm -f conftest.err conftest.$ac_objext
2525 < done
2526 < rm -f conftest.$ac_ext conftest.$ac_objext
2527 < CC=$ac_save_CC
2528 <
2529 < fi
2530 <
2531 < case "x$ac_cv_prog_cc_stdc" in
2532 <  x|xno)
2533 <    echo "$as_me:$LINENO: result: none needed" >&5
2534 < echo "${ECHO_T}none needed" >&6 ;;
2535 <  *)
2536 <    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2537 < echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2538 <    CC="$CC $ac_cv_prog_cc_stdc" ;;
2539 < esac
2540 <
2541 < # Some people use a C++ compiler to compile C.  Since we use `exit',
2542 < # in C++ we need to declare it.  In case someone uses the same compiler
2543 < # for both compiling C and C++ we need to have the C++ compiler decide
2544 < # the declaration of exit, since it's the most demanding environment.
2545 < cat >conftest.$ac_ext <<_ACEOF
2546 < #ifndef __cplusplus
2547 <  choke me
2548 < #endif
2549 < _ACEOF
2550 < rm -f conftest.$ac_objext
2551 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2552 <  (eval $ac_compile) 2>conftest.er1
2553 <  ac_status=$?
2554 <  grep -v '^ *+' conftest.er1 >conftest.err
2555 <  rm -f conftest.er1
2556 <  cat conftest.err >&5
2557 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2558 <  (exit $ac_status); } &&
2559 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2560 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2561 <  (eval $ac_try) 2>&5
2562 <  ac_status=$?
2563 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2564 <  (exit $ac_status); }; } &&
2565 <         { ac_try='test -s conftest.$ac_objext'
2566 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2567 <  (eval $ac_try) 2>&5
2568 <  ac_status=$?
2569 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2570 <  (exit $ac_status); }; }; then
2571 <  for ac_declaration in \
2095 > for ac_declaration in \
2096     '' \
2097     'extern "C" void std::exit (int) throw (); using std::exit;' \
2098     'extern "C" void std::exit (int); using std::exit;' \
# Line 2601 | Line 2125 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2125    cat conftest.err >&5
2126    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2127    (exit $ac_status); } &&
2128 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2128 >         { ac_try='test -z "$ac_cxx_werror_flag"
2129 >                         || test ! -s conftest.err'
2130    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2131    (eval $ac_try) 2>&5
2132    ac_status=$?
# Line 2645 | Line 2170 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2170    cat conftest.err >&5
2171    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2172    (exit $ac_status); } &&
2173 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
2173 >         { ac_try='test -z "$ac_cxx_werror_flag"
2174 >                         || test ! -s conftest.err'
2175    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2176    (eval $ac_try) 2>&5
2177    ac_status=$?
# Line 2672 | Line 2198 | fi
2198    echo '#endif'             >>confdefs.h
2199   fi
2200  
2675 – else
2676 –  echo "$as_me: failed program was:" >&5
2677 – sed 's/^/| /' conftest.$ac_ext >&5
2678 –
2679 – fi
2680 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2201   ac_ext=c
2202   ac_cpp='$CPP $CPPFLAGS'
2203   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2204   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2205   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2206  
2207 <
2208 < ac_ext=cc
2209 < ac_cpp='$CXXCPP $CPPFLAGS'
2210 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2211 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2692 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2207 > ac_ext=c
2208 > ac_cpp='$CPP $CPPFLAGS'
2209 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2210 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2211 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
2212   if test -n "$ac_tool_prefix"; then
2213 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2213 >  for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2214    do
2215      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2216   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2217   echo "$as_me:$LINENO: checking for $ac_word" >&5
2218   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2219 < if test "${ac_cv_prog_CXX+set}" = set; then
2219 > if test "${ac_cv_prog_CC+set}" = set; then
2220    echo $ECHO_N "(cached) $ECHO_C" >&6
2221   else
2222 <  if test -n "$CXX"; then
2223 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2222 >  if test -n "$CC"; then
2223 >  ac_cv_prog_CC="$CC" # Let the user override the test.
2224   else
2225   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2226   for as_dir in $PATH
# Line 2710 | Line 2229 | do
2229    test -z "$as_dir" && as_dir=.
2230    for ac_exec_ext in '' $ac_executable_extensions; do
2231    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2232 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2232 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2233      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2234      break 2
2235    fi
# Line 2719 | Line 2238 | fi
2238  
2239   fi
2240   fi
2241 < CXX=$ac_cv_prog_CXX
2242 < if test -n "$CXX"; then
2243 <  echo "$as_me:$LINENO: result: $CXX" >&5
2244 < echo "${ECHO_T}$CXX" >&6
2241 > CC=$ac_cv_prog_CC
2242 > if test -n "$CC"; then
2243 >  echo "$as_me:$LINENO: result: $CC" >&5
2244 > echo "${ECHO_T}$CC" >&6
2245   else
2246    echo "$as_me:$LINENO: result: no" >&5
2247   echo "${ECHO_T}no" >&6
2248   fi
2249  
2250 <    test -n "$CXX" && break
2250 >    test -n "$CC" && break
2251    done
2252   fi
2253 < if test -z "$CXX"; then
2254 <  ac_ct_CXX=$CXX
2255 <  for ac_prog in $CCC icpc icc xlc++ xlC CC g++ c++
2253 > if test -z "$CC"; then
2254 >  ac_ct_CC=$CC
2255 >  for ac_prog in mpicc icc pathcc pgcc cc xlc gcc
2256   do
2257    # Extract the first word of "$ac_prog", so it can be a program name with args.
2258   set dummy $ac_prog; ac_word=$2
2259   echo "$as_me:$LINENO: checking for $ac_word" >&5
2260   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2261 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
2261 > if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2262    echo $ECHO_N "(cached) $ECHO_C" >&6
2263   else
2264 <  if test -n "$ac_ct_CXX"; then
2265 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2264 >  if test -n "$ac_ct_CC"; then
2265 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2266   else
2267   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2268   for as_dir in $PATH
# Line 2752 | Line 2271 | do
2271    test -z "$as_dir" && as_dir=.
2272    for ac_exec_ext in '' $ac_executable_extensions; do
2273    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2274 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
2274 >    ac_cv_prog_ac_ct_CC="$ac_prog"
2275      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2276      break 2
2277    fi
# Line 2761 | Line 2280 | fi
2280  
2281   fi
2282   fi
2283 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2284 < if test -n "$ac_ct_CXX"; then
2285 <  echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2286 < echo "${ECHO_T}$ac_ct_CXX" >&6
2283 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
2284 > if test -n "$ac_ct_CC"; then
2285 >  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2286 > echo "${ECHO_T}$ac_ct_CC" >&6
2287   else
2288    echo "$as_me:$LINENO: result: no" >&5
2289   echo "${ECHO_T}no" >&6
2290   fi
2291  
2292 <  test -n "$ac_ct_CXX" && break
2293 < done
2775 < test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
2292 >  test -n "$ac_ct_CC" && break
2293 > done
2294  
2295 <  CXX=$ac_ct_CXX
2295 >  CC=$ac_ct_CC
2296   fi
2297  
2298  
2299 + test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2300 + See \`config.log' for more details." >&5
2301 + echo "$as_me: error: no acceptable C compiler found in \$PATH
2302 + See \`config.log' for more details." >&2;}
2303 +   { (exit 1); exit 1; }; }
2304 +
2305   # Provide some information about the compiler.
2306   echo "$as_me:$LINENO:" \
2307 <     "checking for C++ compiler version" >&5
2307 >     "checking for C compiler version" >&5
2308   ac_compiler=`set X $ac_compile; echo $2`
2309   { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2310    (eval $ac_compiler --version </dev/null >&5) 2>&5
# Line 2798 | Line 2322 | ac_compiler=`set X $ac_compile; echo $2`
2322    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2323    (exit $ac_status); }
2324  
2325 < echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2326 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
2327 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2325 > echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
2326 > echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
2327 > if test "${ac_cv_c_compiler_gnu+set}" = set; then
2328    echo $ECHO_N "(cached) $ECHO_C" >&6
2329   else
2330    cat >conftest.$ac_ext <<_ACEOF
# Line 2830 | Line 2354 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2354    cat conftest.err >&5
2355    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2356    (exit $ac_status); } &&
2357 <         { ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
2357 >         { ac_try='test -z "$ac_c_werror_flag"
2358 >                         || test ! -s conftest.err'
2359    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2360    (eval $ac_try) 2>&5
2361    ac_status=$?
# Line 2850 | Line 2375 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2375   ac_compiler_gnu=no
2376   fi
2377   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2378 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2378 > ac_cv_c_compiler_gnu=$ac_compiler_gnu
2379  
2380   fi
2381 < echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2382 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
2383 < GXX=`test $ac_compiler_gnu = yes && echo yes`
2384 < ac_test_CXXFLAGS=${CXXFLAGS+set}
2385 < ac_save_CXXFLAGS=$CXXFLAGS
2386 < CXXFLAGS="-g"
2387 < echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2388 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
2389 < if test "${ac_cv_prog_cxx_g+set}" = set; then
2381 > echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
2382 > echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
2383 > GCC=`test $ac_compiler_gnu = yes && echo yes`
2384 > ac_test_CFLAGS=${CFLAGS+set}
2385 > ac_save_CFLAGS=$CFLAGS
2386 > CFLAGS="-g"
2387 > echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
2388 > echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
2389 > if test "${ac_cv_prog_cc_g+set}" = set; then
2390    echo $ECHO_N "(cached) $ECHO_C" >&6
2391   else
2392    cat >conftest.$ac_ext <<_ACEOF
# Line 2888 | Line 2413 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2413    cat conftest.err >&5
2414    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2415    (exit $ac_status); } &&
2416 <         { ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
2416 >         { ac_try='test -z "$ac_c_werror_flag"
2417 >                         || test ! -s conftest.err'
2418    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2419    (eval $ac_try) 2>&5
2420    ac_status=$?
# Line 2900 | Line 2426 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2426    ac_status=$?
2427    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2428    (exit $ac_status); }; }; then
2429 <  ac_cv_prog_cxx_g=yes
2429 >  ac_cv_prog_cc_g=yes
2430   else
2431    echo "$as_me: failed program was:" >&5
2432   sed 's/^/| /' conftest.$ac_ext >&5
2433  
2434 < ac_cv_prog_cxx_g=no
2434 > ac_cv_prog_cc_g=no
2435   fi
2436   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2437   fi
2438 < echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2439 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
2440 < if test "$ac_test_CXXFLAGS" = set; then
2441 <  CXXFLAGS=$ac_save_CXXFLAGS
2442 < elif test $ac_cv_prog_cxx_g = yes; then
2443 <  if test "$GXX" = yes; then
2444 <    CXXFLAGS="-g -O2"
2438 > echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
2439 > echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
2440 > if test "$ac_test_CFLAGS" = set; then
2441 >  CFLAGS=$ac_save_CFLAGS
2442 > elif test $ac_cv_prog_cc_g = yes; then
2443 >  if test "$GCC" = yes; then
2444 >    CFLAGS="-g -O2"
2445    else
2446 <    CXXFLAGS="-g"
2446 >    CFLAGS="-g"
2447    fi
2448   else
2449 <  if test "$GXX" = yes; then
2450 <    CXXFLAGS="-O2"
2449 >  if test "$GCC" = yes; then
2450 >    CFLAGS="-O2"
2451    else
2452 <    CXXFLAGS=
2452 >    CFLAGS=
2453    fi
2454   fi
2455 < for ac_declaration in \
2456 <   '' \
2457 <   'extern "C" void std::exit (int) throw (); using std::exit;' \
2458 <   'extern "C" void std::exit (int); using std::exit;' \
2459 <   'extern "C" void exit (int) throw ();' \
2460 <   'extern "C" void exit (int);' \
2461 <   'void exit (int);'
2462 < do
2937 <  cat >conftest.$ac_ext <<_ACEOF
2455 > echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
2456 > echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2457 > if test "${ac_cv_prog_cc_stdc+set}" = set; then
2458 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2459 > else
2460 >  ac_cv_prog_cc_stdc=no
2461 > ac_save_CC=$CC
2462 > cat >conftest.$ac_ext <<_ACEOF
2463   /* confdefs.h.  */
2464   _ACEOF
2465   cat confdefs.h >>conftest.$ac_ext
2466   cat >>conftest.$ac_ext <<_ACEOF
2467   /* end confdefs.h.  */
2468 < $ac_declaration
2469 < #include <stdlib.h>
2470 < int
2471 < main ()
2468 > #include <stdarg.h>
2469 > #include <stdio.h>
2470 > #include <sys/types.h>
2471 > #include <sys/stat.h>
2472 > /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2473 > struct buf { int x; };
2474 > FILE * (*rcsopen) (struct buf *, struct stat *, int);
2475 > static char *e (p, i)
2476 >     char **p;
2477 >     int i;
2478   {
2479 < exit (42);
2949 <  ;
2950 <  return 0;
2479 >  return p[i];
2480   }
2481 < _ACEOF
2482 < rm -f conftest.$ac_objext
2483 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2484 <  (eval $ac_compile) 2>conftest.er1
2485 <  ac_status=$?
2486 <  grep -v '^ *+' conftest.er1 >conftest.err
2487 <  rm -f conftest.er1
2488 <  cat conftest.err >&5
2489 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2490 <  (exit $ac_status); } &&
2491 <         { ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
2481 > static char *f (char * (*g) (char **, int), char **p, ...)
2482 > {
2483 >  char *s;
2484 >  va_list v;
2485 >  va_start (v,p);
2486 >  s = g (p, va_arg (v,int));
2487 >  va_end (v);
2488 >  return s;
2489 > }
2490 >
2491 > /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2492 >   function prototypes and stuff, but not '\xHH' hex character constants.
2493 >   These don't provoke an error unfortunately, instead are silently treated
2494 >   as 'x'.  The following induces an error, until -std1 is added to get
2495 >   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2496 >   array size at least.  It's necessary to write '\x00'==0 to get something
2497 >   that's true only with -std1.  */
2498 > int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2499 >
2500 > int test (int i, double x);
2501 > struct s1 {int (*f) (int a);};
2502 > struct s2 {int (*f) (double a);};
2503 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2504 > int argc;
2505 > char **argv;
2506 > int
2507 > main ()
2508 > {
2509 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2510 >  ;
2511 >  return 0;
2512 > }
2513 > _ACEOF
2514 > # Don't try gcc -ansi; that turns off useful extensions and
2515 > # breaks some systems' header files.
2516 > # AIX                   -qlanglvl=ansi
2517 > # Ultrix and OSF/1      -std1
2518 > # HP-UX 10.20 and later -Ae
2519 > # HP-UX older versions  -Aa -D_HPUX_SOURCE
2520 > # SVR4                  -Xc -D__EXTENSIONS__
2521 > for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2522 > do
2523 >  CC="$ac_save_CC $ac_arg"
2524 >  rm -f conftest.$ac_objext
2525 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2526 >  (eval $ac_compile) 2>conftest.er1
2527 >  ac_status=$?
2528 >  grep -v '^ *+' conftest.er1 >conftest.err
2529 >  rm -f conftest.er1
2530 >  cat conftest.err >&5
2531 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2532 >  (exit $ac_status); } &&
2533 >         { ac_try='test -z "$ac_c_werror_flag"
2534 >                         || test ! -s conftest.err'
2535 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2536 >  (eval $ac_try) 2>&5
2537 >  ac_status=$?
2538 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2539 >  (exit $ac_status); }; } &&
2540 >         { ac_try='test -s conftest.$ac_objext'
2541 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2542 >  (eval $ac_try) 2>&5
2543 >  ac_status=$?
2544 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2545 >  (exit $ac_status); }; }; then
2546 >  ac_cv_prog_cc_stdc=$ac_arg
2547 > break
2548 > else
2549 >  echo "$as_me: failed program was:" >&5
2550 > sed 's/^/| /' conftest.$ac_ext >&5
2551 >
2552 > fi
2553 > rm -f conftest.err conftest.$ac_objext
2554 > done
2555 > rm -f conftest.$ac_ext conftest.$ac_objext
2556 > CC=$ac_save_CC
2557 >
2558 > fi
2559 >
2560 > case "x$ac_cv_prog_cc_stdc" in
2561 >  x|xno)
2562 >    echo "$as_me:$LINENO: result: none needed" >&5
2563 > echo "${ECHO_T}none needed" >&6 ;;
2564 >  *)
2565 >    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2566 > echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2567 >    CC="$CC $ac_cv_prog_cc_stdc" ;;
2568 > esac
2569 >
2570 > # Some people use a C++ compiler to compile C.  Since we use `exit',
2571 > # in C++ we need to declare it.  In case someone uses the same compiler
2572 > # for both compiling C and C++ we need to have the C++ compiler decide
2573 > # the declaration of exit, since it's the most demanding environment.
2574 > cat >conftest.$ac_ext <<_ACEOF
2575 > #ifndef __cplusplus
2576 >  choke me
2577 > #endif
2578 > _ACEOF
2579 > rm -f conftest.$ac_objext
2580 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2581 >  (eval $ac_compile) 2>conftest.er1
2582 >  ac_status=$?
2583 >  grep -v '^ *+' conftest.er1 >conftest.err
2584 >  rm -f conftest.er1
2585 >  cat conftest.err >&5
2586 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2587 >  (exit $ac_status); } &&
2588 >         { ac_try='test -z "$ac_c_werror_flag"
2589 >                         || test ! -s conftest.err'
2590 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2591 >  (eval $ac_try) 2>&5
2592 >  ac_status=$?
2593 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2594 >  (exit $ac_status); }; } &&
2595 >         { ac_try='test -s conftest.$ac_objext'
2596 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2597 >  (eval $ac_try) 2>&5
2598 >  ac_status=$?
2599 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2600 >  (exit $ac_status); }; }; then
2601 >  for ac_declaration in \
2602 >   '' \
2603 >   'extern "C" void std::exit (int) throw (); using std::exit;' \
2604 >   'extern "C" void std::exit (int); using std::exit;' \
2605 >   'extern "C" void exit (int) throw ();' \
2606 >   'extern "C" void exit (int);' \
2607 >   'void exit (int);'
2608 > do
2609 >  cat >conftest.$ac_ext <<_ACEOF
2610 > /* confdefs.h.  */
2611 > _ACEOF
2612 > cat confdefs.h >>conftest.$ac_ext
2613 > cat >>conftest.$ac_ext <<_ACEOF
2614 > /* end confdefs.h.  */
2615 > $ac_declaration
2616 > #include <stdlib.h>
2617 > int
2618 > main ()
2619 > {
2620 > exit (42);
2621 >  ;
2622 >  return 0;
2623 > }
2624 > _ACEOF
2625 > rm -f conftest.$ac_objext
2626 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2627 >  (eval $ac_compile) 2>conftest.er1
2628 >  ac_status=$?
2629 >  grep -v '^ *+' conftest.er1 >conftest.err
2630 >  rm -f conftest.er1
2631 >  cat conftest.err >&5
2632 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2633 >  (exit $ac_status); } &&
2634 >         { ac_try='test -z "$ac_c_werror_flag"
2635 >                         || test ! -s conftest.err'
2636    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2637    (eval $ac_try) 2>&5
2638    ac_status=$?
# Line 3003 | Line 2676 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2676    cat conftest.err >&5
2677    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2678    (exit $ac_status); } &&
2679 <         { ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
2679 >         { ac_try='test -z "$ac_c_werror_flag"
2680 >                         || test ! -s conftest.err'
2681    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2682    (eval $ac_try) 2>&5
2683    ac_status=$?
# Line 3030 | Line 2704 | fi
2704    echo '#endif'             >>confdefs.h
2705   fi
2706  
2707 + else
2708 +  echo "$as_me: failed program was:" >&5
2709 + sed 's/^/| /' conftest.$ac_ext >&5
2710 +
2711 + fi
2712 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2713   ac_ext=c
2714   ac_cpp='$CPP $CPPFLAGS'
2715   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2716   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2717   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2718  
2719 <
2720 < OOPSE_TEMPLATE_FLAGS=""
2721 < if test $ac_cv_cxx_compiler_gnu = no; then
2722 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3043 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3044 <  echo 'void f(){}' > conftest.cc
3045 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3046 <    echo "$as_me:$LINENO: result: yes" >&5
3047 < echo "${ECHO_T}yes" >&6
3048 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3049 <  else
3050 <    echo "$as_me:$LINENO: result: no" >&5
3051 < echo "${ECHO_T}no" >&6
3052 <  fi
3053 <  rm -f conftest*
3054 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3055 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3056 <  echo 'void f(){}' > conftest.cc
3057 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3058 <    echo "$as_me:$LINENO: result: yes" >&5
3059 < echo "${ECHO_T}yes" >&6
3060 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3061 <  else
3062 <    echo "$as_me:$LINENO: result: no" >&5
3063 < echo "${ECHO_T}no" >&6
3064 <  fi
3065 <  rm -f conftest*
3066 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3067 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3068 <  echo 'void f(){}' > conftest.cc
3069 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3070 <    echo "$as_me:$LINENO: result: yes" >&5
3071 < echo "${ECHO_T}yes" >&6
3072 <    OOPSE_TEMPLATE_FLAGS="-pto"
3073 <  else
3074 <    echo "$as_me:$LINENO: result: no" >&5
3075 < echo "${ECHO_T}no" >&6
3076 <  fi
3077 <  rm -f conftest*
3078 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3079 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3080 <  echo 'void f(){}' > conftest.cc
3081 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3082 <    echo "$as_me:$LINENO: result: yes" >&5
3083 < echo "${ECHO_T}yes" >&6
3084 <
3085 <
3086 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3087 <  else
3088 <    echo "$as_me:$LINENO: result: no" >&5
3089 < echo "${ECHO_T}no" >&6
3090 <  fi
3091 < fi
3092 <
3093 <
3094 <
3095 <
3096 < ac_ext=f90
3097 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3098 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3099 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
2719 > ac_ext=${FC_SRCEXT-f}
2720 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
2721 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
2722 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2723   if test -n "$ac_tool_prefix"; then
2724 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2724 >  for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2725    do
2726      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2727   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2728   echo "$as_me:$LINENO: checking for $ac_word" >&5
2729   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2730 < if test "${ac_cv_prog_F90+set}" = set; then
2730 > if test "${ac_cv_prog_FC+set}" = set; then
2731    echo $ECHO_N "(cached) $ECHO_C" >&6
2732   else
2733 <  if test -n "$F90"; then
2734 <  ac_cv_prog_F90="$F90" # Let the user override the test.
2733 >  if test -n "$FC"; then
2734 >  ac_cv_prog_FC="$FC" # Let the user override the test.
2735   else
2736   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2737   for as_dir in $PATH
# Line 3117 | Line 2740 | do
2740    test -z "$as_dir" && as_dir=.
2741    for ac_exec_ext in '' $ac_executable_extensions; do
2742    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2743 <    ac_cv_prog_F90="$ac_tool_prefix$ac_prog"
2743 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
2744      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2745      break 2
2746    fi
# Line 3126 | Line 2749 | fi
2749  
2750   fi
2751   fi
2752 < F90=$ac_cv_prog_F90
2753 < if test -n "$F90"; then
2754 <  echo "$as_me:$LINENO: result: $F90" >&5
2755 < echo "${ECHO_T}$F90" >&6
2752 > FC=$ac_cv_prog_FC
2753 > if test -n "$FC"; then
2754 >  echo "$as_me:$LINENO: result: $FC" >&5
2755 > echo "${ECHO_T}$FC" >&6
2756   else
2757    echo "$as_me:$LINENO: result: no" >&5
2758   echo "${ECHO_T}no" >&6
2759   fi
2760  
2761 <    test -n "$F90" && break
2761 >    test -n "$FC" && break
2762    done
2763   fi
2764 < if test -z "$F90"; then
2765 <  ac_ct_F90=$F90
2766 <  for ac_prog in ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
2764 > if test -z "$FC"; then
2765 >  ac_ct_FC=$FC
2766 >  for ac_prog in mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
2767   do
2768    # Extract the first word of "$ac_prog", so it can be a program name with args.
2769   set dummy $ac_prog; ac_word=$2
2770   echo "$as_me:$LINENO: checking for $ac_word" >&5
2771   echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2772 < if test "${ac_cv_prog_ac_ct_F90+set}" = set; then
2772 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
2773    echo $ECHO_N "(cached) $ECHO_C" >&6
2774   else
2775 <  if test -n "$ac_ct_F90"; then
2776 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
2775 >  if test -n "$ac_ct_FC"; then
2776 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
2777   else
2778   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2779   for as_dir in $PATH
# Line 3159 | Line 2782 | do
2782    test -z "$as_dir" && as_dir=.
2783    for ac_exec_ext in '' $ac_executable_extensions; do
2784    if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2785 <    ac_cv_prog_ac_ct_F90="$ac_prog"
2785 >    ac_cv_prog_ac_ct_FC="$ac_prog"
2786      echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2787      break 2
2788    fi
# Line 3168 | Line 2791 | fi
2791  
2792   fi
2793   fi
2794 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
2795 < if test -n "$ac_ct_F90"; then
2796 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
2797 < echo "${ECHO_T}$ac_ct_F90" >&6
2794 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
2795 > if test -n "$ac_ct_FC"; then
2796 >  echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
2797 > echo "${ECHO_T}$ac_ct_FC" >&6
2798   else
2799    echo "$as_me:$LINENO: result: no" >&5
2800   echo "${ECHO_T}no" >&6
2801   fi
2802  
2803 <  test -n "$ac_ct_F90" && break
2803 >  test -n "$ac_ct_FC" && break
2804   done
2805  
2806 <  F90=$ac_ct_F90
2806 >  FC=$ac_ct_FC
2807   fi
2808  
2809  
2810 < # If we don't use `.F90' as extension, the preprocessor is not run on the
2811 < # input file.
2810 > # Provide some information about the compiler.
2811 > echo "$as_me:2811:" \
2812 >     "checking for Fortran compiler version" >&5
2813 > ac_compiler=`set X $ac_compile; echo $2`
2814 > { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
2815 >  (eval $ac_compiler --version </dev/null >&5) 2>&5
2816 >  ac_status=$?
2817 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2818 >  (exit $ac_status); }
2819 > { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
2820 >  (eval $ac_compiler -v </dev/null >&5) 2>&5
2821 >  ac_status=$?
2822 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2823 >  (exit $ac_status); }
2824 > { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
2825 >  (eval $ac_compiler -V </dev/null >&5) 2>&5
2826 >  ac_status=$?
2827 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2828 >  (exit $ac_status); }
2829 > rm -f a.out
2830 >
2831 > # If we don't use `.F' as extension, the preprocessor is not run on the
2832 > # input file.  (Note that this only needs to work for GNU compilers.)
2833   ac_save_ext=$ac_ext
2834 < ac_ext=F90
2835 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
2836 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
2837 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
2834 > ac_ext=F
2835 > echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
2836 > echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6
2837 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then
2838    echo $ECHO_N "(cached) $ECHO_C" >&6
2839   else
2840    cat >conftest.$ac_ext <<_ACEOF
2841 <
3198 < program main
3199 <
2841 >      program main
2842   #ifndef __GNUC__
2843         choke me
2844   #endif
2845  
2846 < end program main
3205 <
2846 >      end
2847   _ACEOF
2848   rm -f conftest.$ac_objext
2849   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3213 | Line 2854 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2854    cat conftest.err >&5
2855    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2856    (exit $ac_status); } &&
2857 <         { ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
2857 >         { ac_try='test -z "$ac_fc_werror_flag"
2858 >                         || test ! -s conftest.err'
2859    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2860    (eval $ac_try) 2>&5
2861    ac_status=$?
# Line 3233 | Line 2875 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
2875   ac_compiler_gnu=no
2876   fi
2877   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2878 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
2878 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2879  
2880   fi
2881 < echo "$as_me:$LINENO: result: $ac_cv_f90_compiler_gnu" >&5
2882 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
2881 > echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
2882 > echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6
2883   ac_ext=$ac_save_ext
2884 < G95=`test $ac_compiler_gnu = yes && echo yes`
2885 < ac_ext=c
2886 < ac_cpp='$CPP $CPPFLAGS'
2887 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2888 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2889 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
2884 > ac_test_FFLAGS=${FCFLAGS+set}
2885 > ac_save_FFLAGS=$FCFLAGS
2886 > FCFLAGS=
2887 > echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
2888 > echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6
2889 > if test "${ac_cv_prog_fc_g+set}" = set; then
2890 >  echo $ECHO_N "(cached) $ECHO_C" >&6
2891 > else
2892 >  FCFLAGS=-g
2893 > cat >conftest.$ac_ext <<_ACEOF
2894 >      program main
2895  
2896 <
3250 <
3251 <
3252 <
3253 < # Try to determine native compiler flags that allow us to use F90 suffix
3254 < # for preprocessed f90 source.
3255 <
3256 < if test "$ac_test_PREPFLAG" != "set"; then
3257 <  PREPFLAG=""
3258 <  case "${host_cpu}-${host_os}" in
3259 <
3260 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3261 <                    PREPFLAG="-fpp1 "
3262 <                fi;;
3263 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3264 <                    PREPFLAG="-qsuffix=cpp=F90 "
3265 <                fi;;
3266 <  *darwin*)
3267 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3268 <                PREPFLAG="-qsuffix=cpp=F90 "
3269 <        fi;;
3270 <  esac
3271 <
3272 <  if test -z "$PREPFLAG"; then
3273 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3274 < echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3275 <        PREPFLAG=""
3276 <  fi
3277 <
3278 <  echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3279 < echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3280 <
3281 <
3282 <  ac_ext=f90
3283 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3284 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3285 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3286 <
3287 <  ac_save_ext=$ac_ext
3288 <  ac_ext=F90
3289 <  ac_save_F90FLAGS=$F90FLAGS
3290 <
3291 <  if test "$PREPFLAG"; then
3292 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3293 < fi
3294 <
3295 <    cat >conftest.$ac_ext <<_ACEOF
3296 <
3297 <
3298 < program main
3299 <
3300 <  integer :: i
3301 <  i = 1
3302 <
3303 <
3304 < end program main
3305 <
2896 >      end
2897   _ACEOF
2898   rm -f conftest.$ac_objext
2899   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3313 | Line 2904 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2904    cat conftest.err >&5
2905    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2906    (exit $ac_status); } &&
2907 <         { ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
2907 >         { ac_try='test -z "$ac_fc_werror_flag"
2908 >                         || test ! -s conftest.err'
2909    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2910    (eval $ac_try) 2>&5
2911    ac_status=$?
# Line 3325 | Line 2917 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2917    ac_status=$?
2918    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2919    (exit $ac_status); }; }; then
2920 <  prepflagworks=1
2920 >  ac_cv_prog_fc_g=yes
2921   else
2922    echo "$as_me: failed program was:" >&5
2923   sed 's/^/| /' conftest.$ac_ext >&5
2924  
2925 < prepflagworks=0
2925 > ac_cv_prog_fc_g=no
2926   fi
2927   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2928  
2929 <  F90FLAGS=$ac_save_F90FLAGS
2930 <  ac_ext=$ac_save_ext
2931 <  ac_ext=c
2929 > fi
2930 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
2931 > echo "${ECHO_T}$ac_cv_prog_fc_g" >&6
2932 > if test "$ac_test_FFLAGS" = set; then
2933 >  FCFLAGS=$ac_save_FFLAGS
2934 > elif test $ac_cv_prog_fc_g = yes; then
2935 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2936 >    FCFLAGS="-g -O2"
2937 >  else
2938 >    FCFLAGS="-g"
2939 >  fi
2940 > else
2941 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
2942 >    FCFLAGS="-O2"
2943 >  else
2944 >    FCFLAGS=
2945 >  fi
2946 > fi
2947 >
2948 > ac_ext=c
2949   ac_cpp='$CPP $CPPFLAGS'
2950   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2951   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2952   ac_compiler_gnu=$ac_cv_c_compiler_gnu
2953  
2954 + ac_ext=c
2955 + ac_cpp='$CPP $CPPFLAGS'
2956 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2957 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2958 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
2959 + echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
2960 + echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
2961 + # On Suns, sometimes $CPP names a directory.
2962 + if test -n "$CPP" && test -d "$CPP"; then
2963 +  CPP=
2964 + fi
2965 + if test -z "$CPP"; then
2966 +  if test "${ac_cv_prog_CPP+set}" = set; then
2967 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2968 + else
2969 +      # Double quotes because CPP needs to be expanded
2970 +    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
2971 +    do
2972 +      ac_preproc_ok=false
2973 + for ac_c_preproc_warn_flag in '' yes
2974 + do
2975 +  # Use a header file that comes with gcc, so configuring glibc
2976 +  # with a fresh cross-compiler works.
2977 +  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
2978 +  # <limits.h> exists even on freestanding compilers.
2979 +  # On the NeXT, cc -E runs the code through the compiler's parser,
2980 +  # not just through cpp. "Syntax error" is here to catch this case.
2981 +  cat >conftest.$ac_ext <<_ACEOF
2982 + /* confdefs.h.  */
2983 + _ACEOF
2984 + cat confdefs.h >>conftest.$ac_ext
2985 + cat >>conftest.$ac_ext <<_ACEOF
2986 + /* end confdefs.h.  */
2987 + #ifdef __STDC__
2988 + # include <limits.h>
2989 + #else
2990 + # include <assert.h>
2991 + #endif
2992 +                     Syntax error
2993 + _ACEOF
2994 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
2995 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
2996 +  ac_status=$?
2997 +  grep -v '^ *+' conftest.er1 >conftest.err
2998 +  rm -f conftest.er1
2999 +  cat conftest.err >&5
3000 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3001 +  (exit $ac_status); } >/dev/null; then
3002 +  if test -s conftest.err; then
3003 +    ac_cpp_err=$ac_c_preproc_warn_flag
3004 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3005 +  else
3006 +    ac_cpp_err=
3007 +  fi
3008 + else
3009 +  ac_cpp_err=yes
3010 + fi
3011 + if test -z "$ac_cpp_err"; then
3012 +  :
3013 + else
3014 +  echo "$as_me: failed program was:" >&5
3015 + sed 's/^/| /' conftest.$ac_ext >&5
3016  
3017 <  if test "$prepflagworks" = 1; then
3018 <    echo "$as_me:$LINENO: result: yes" >&5
3019 < echo "${ECHO_T}yes" >&6
3017 >  # Broken: fails on valid input.
3018 > continue
3019 > fi
3020 > rm -f conftest.err conftest.$ac_ext
3021  
3022 +  # OK, works on sane cases.  Now check whether non-existent headers
3023 +  # can be detected and how.
3024 +  cat >conftest.$ac_ext <<_ACEOF
3025 + /* confdefs.h.  */
3026 + _ACEOF
3027 + cat confdefs.h >>conftest.$ac_ext
3028 + cat >>conftest.$ac_ext <<_ACEOF
3029 + /* end confdefs.h.  */
3030 + #include <ac_nonexistent.h>
3031 + _ACEOF
3032 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3033 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3034 +  ac_status=$?
3035 +  grep -v '^ *+' conftest.er1 >conftest.err
3036 +  rm -f conftest.er1
3037 +  cat conftest.err >&5
3038 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3039 +  (exit $ac_status); } >/dev/null; then
3040 +  if test -s conftest.err; then
3041 +    ac_cpp_err=$ac_c_preproc_warn_flag
3042 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3043    else
3044 <    echo "$as_me:$LINENO: result: no" >&5
3352 < echo "${ECHO_T}no" >&6
3353 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3354 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3355 <   { (exit 1); exit 1; }; }
3044 >    ac_cpp_err=
3045    fi
3046 + else
3047 +  ac_cpp_err=yes
3048   fi
3049 + if test -z "$ac_cpp_err"; then
3050 +  # Broken: success on invalid input.
3051 + continue
3052 + else
3053 +  echo "$as_me: failed program was:" >&5
3054 + sed 's/^/| /' conftest.$ac_ext >&5
3055  
3056 +  # Passes both tests.
3057 + ac_preproc_ok=:
3058 + break
3059 + fi
3060 + rm -f conftest.err conftest.$ac_ext
3061  
3062 <
3063 <
3064 <
3065 < # Try to determine native compiler flags that allow us to use F90 suffix
3066 < # for preprocessed f90 source with -D type defines
3365 <
3366 < if test "$ac_test_PREPDEFFLAG" != "set"; then
3367 <  PREPDEFFLAG=""
3368 <  case "${host_cpu}-${host_os}" in
3369 <
3370 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3371 <                    PREPDEFFLAG=" "
3372 <                fi;;
3373 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3374 <                    PREPDEFFLAG="-WF,"
3375 <                fi;;
3376 <  *darwin*)
3377 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3378 <                PREPDEFFLAG="-WF,"
3379 <        fi;;
3380 <  esac
3381 <
3382 <  if test -z "$PREPDEFFLAG"; then
3383 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3384 < echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3385 <        PREPDEFFLAG=" "
3386 <  fi
3387 <
3388 <  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3389 < echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3390 <
3391 <
3392 <  ac_ext=f90
3393 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3394 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3395 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3396 <
3397 <  ac_save_ext=$ac_ext
3398 <  ac_ext=F90
3399 <  ac_save_F90FLAGS=$F90FLAGS
3400 <
3401 <  if test "$PREPDEFFLAG"; then
3402 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3062 > done
3063 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3064 > rm -f conftest.err conftest.$ac_ext
3065 > if $ac_preproc_ok; then
3066 >  break
3067   fi
3068  
3069 <    cat >conftest.$ac_ext <<_ACEOF
3069 >    done
3070 >    ac_cv_prog_CPP=$CPP
3071  
3072 <
3073 < program main
3074 <
3075 <  integer :: i
3076 < #ifdef TEST
3077 <  i = 1
3072 > fi
3073 >  CPP=$ac_cv_prog_CPP
3074 > else
3075 >  ac_cv_prog_CPP=$CPP
3076 > fi
3077 > echo "$as_me:$LINENO: result: $CPP" >&5
3078 > echo "${ECHO_T}$CPP" >&6
3079 > ac_preproc_ok=false
3080 > for ac_c_preproc_warn_flag in '' yes
3081 > do
3082 >  # Use a header file that comes with gcc, so configuring glibc
3083 >  # with a fresh cross-compiler works.
3084 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
3085 >  # <limits.h> exists even on freestanding compilers.
3086 >  # On the NeXT, cc -E runs the code through the compiler's parser,
3087 >  # not just through cpp. "Syntax error" is here to catch this case.
3088 >  cat >conftest.$ac_ext <<_ACEOF
3089 > /* confdefs.h.  */
3090 > _ACEOF
3091 > cat confdefs.h >>conftest.$ac_ext
3092 > cat >>conftest.$ac_ext <<_ACEOF
3093 > /* end confdefs.h.  */
3094 > #ifdef __STDC__
3095 > # include <limits.h>
3096   #else
3097 <  choke me
3097 > # include <assert.h>
3098   #endif
3099 +                     Syntax error
3100 + _ACEOF
3101 + if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3102 +  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3103 +  ac_status=$?
3104 +  grep -v '^ *+' conftest.er1 >conftest.err
3105 +  rm -f conftest.er1
3106 +  cat conftest.err >&5
3107 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3108 +  (exit $ac_status); } >/dev/null; then
3109 +  if test -s conftest.err; then
3110 +    ac_cpp_err=$ac_c_preproc_warn_flag
3111 +    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3112 +  else
3113 +    ac_cpp_err=
3114 +  fi
3115 + else
3116 +  ac_cpp_err=yes
3117 + fi
3118 + if test -z "$ac_cpp_err"; then
3119 +  :
3120 + else
3121 +  echo "$as_me: failed program was:" >&5
3122 + sed 's/^/| /' conftest.$ac_ext >&5
3123  
3124 +  # Broken: fails on valid input.
3125 + continue
3126 + fi
3127 + rm -f conftest.err conftest.$ac_ext
3128  
3129 < end program main
3130 <
3129 >  # OK, works on sane cases.  Now check whether non-existent headers
3130 >  # can be detected and how.
3131 >  cat >conftest.$ac_ext <<_ACEOF
3132 > /* confdefs.h.  */
3133   _ACEOF
3134 < rm -f conftest.$ac_objext
3135 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3136 <  (eval $ac_compile) 2>conftest.er1
3134 > cat confdefs.h >>conftest.$ac_ext
3135 > cat >>conftest.$ac_ext <<_ACEOF
3136 > /* end confdefs.h.  */
3137 > #include <ac_nonexistent.h>
3138 > _ACEOF
3139 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
3140 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
3141    ac_status=$?
3142    grep -v '^ *+' conftest.er1 >conftest.err
3143    rm -f conftest.er1
3144    cat conftest.err >&5
3145    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3146 <  (exit $ac_status); } &&
3147 <         { ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
3148 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3149 <  (eval $ac_try) 2>&5
3150 <  ac_status=$?
3151 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3152 <  (exit $ac_status); }; } &&
3436 <         { ac_try='test -s conftest.$ac_objext'
3437 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3438 <  (eval $ac_try) 2>&5
3439 <  ac_status=$?
3440 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3441 <  (exit $ac_status); }; }; then
3442 <  prepdefflagworks=1
3146 >  (exit $ac_status); } >/dev/null; then
3147 >  if test -s conftest.err; then
3148 >    ac_cpp_err=$ac_c_preproc_warn_flag
3149 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
3150 >  else
3151 >    ac_cpp_err=
3152 >  fi
3153   else
3154 +  ac_cpp_err=yes
3155 + fi
3156 + if test -z "$ac_cpp_err"; then
3157 +  # Broken: success on invalid input.
3158 + continue
3159 + else
3160    echo "$as_me: failed program was:" >&5
3161   sed 's/^/| /' conftest.$ac_ext >&5
3162  
3163 < prepdefflagworks=0
3163 >  # Passes both tests.
3164 > ac_preproc_ok=:
3165 > break
3166   fi
3167 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3167 > rm -f conftest.err conftest.$ac_ext
3168  
3169 <  F90FLAGS=$ac_save_F90FLAGS
3170 <  ac_ext=$ac_save_ext
3171 <  ac_ext=c
3169 > done
3170 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
3171 > rm -f conftest.err conftest.$ac_ext
3172 > if $ac_preproc_ok; then
3173 >  :
3174 > else
3175 >  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
3176 > See \`config.log' for more details." >&5
3177 > echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
3178 > See \`config.log' for more details." >&2;}
3179 >   { (exit 1); exit 1; }; }
3180 > fi
3181 >
3182 > ac_ext=c
3183   ac_cpp='$CPP $CPPFLAGS'
3184   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3185   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3186   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3187  
3188 + echo "$as_me:$LINENO: checking for egrep" >&5
3189 + echo $ECHO_N "checking for egrep... $ECHO_C" >&6
3190 + if test "${ac_cv_prog_egrep+set}" = set; then
3191 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3192 + else
3193 +  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
3194 +    then ac_cv_prog_egrep='grep -E'
3195 +    else ac_cv_prog_egrep='egrep'
3196 +    fi
3197 + fi
3198 + echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
3199 + echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3200 + EGREP=$ac_cv_prog_egrep
3201  
3202  
3203 <  if test "$prepdefflagworks" = 1; then
3204 <    echo "$as_me:$LINENO: result: yes" >&5
3203 > echo "$as_me:$LINENO: checking whether ln -s works" >&5
3204 > echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3205 > LN_S=$as_ln_s
3206 > if test "$LN_S" = "ln -s"; then
3207 >  echo "$as_me:$LINENO: result: yes" >&5
3208   echo "${ECHO_T}yes" >&6
3209 + else
3210 +  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
3211 + echo "${ECHO_T}no, using $LN_S" >&6
3212 + fi
3213  
3214 <  else
3215 <    echo "$as_me:$LINENO: result: no" >&5
3214 > echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3215 > echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
3216 > set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
3217 > if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
3218 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3219 > else
3220 >  cat >conftest.make <<\_ACEOF
3221 > all:
3222 >        @echo 'ac_maketemp="$(MAKE)"'
3223 > _ACEOF
3224 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
3225 > eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
3226 > if test -n "$ac_maketemp"; then
3227 >  eval ac_cv_prog_make_${ac_make}_set=yes
3228 > else
3229 >  eval ac_cv_prog_make_${ac_make}_set=no
3230 > fi
3231 > rm -f conftest.make
3232 > fi
3233 > if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
3234 >  echo "$as_me:$LINENO: result: yes" >&5
3235 > echo "${ECHO_T}yes" >&6
3236 >  SET_MAKE=
3237 > else
3238 >  echo "$as_me:$LINENO: result: no" >&5
3239   echo "${ECHO_T}no" >&6
3240 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
3469 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
3470 <   { (exit 1); exit 1; }; }
3471 <  fi
3240 >  SET_MAKE="MAKE=${MAKE-make}"
3241   fi
3242  
3243 < ac_ext=f90
3244 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3245 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3246 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3243 > if test -n "$ac_tool_prefix"; then
3244 >  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3245 > set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3246 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3247 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3248 > if test "${ac_cv_prog_RANLIB+set}" = set; then
3249 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3250 > else
3251 >  if test -n "$RANLIB"; then
3252 >  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3253 > else
3254 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3255 > for as_dir in $PATH
3256 > do
3257 >  IFS=$as_save_IFS
3258 >  test -z "$as_dir" && as_dir=.
3259 >  for ac_exec_ext in '' $ac_executable_extensions; do
3260 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3261 >    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3262 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3263 >    break 2
3264 >  fi
3265 > done
3266 > done
3267  
3479 –
3480 –
3481 – ac_ext=f90
3482 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3483 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3484 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3485 – echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3486 – echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3487 – if test "${ac_cv_prog_f90_v+set}" = set; then
3488 –  echo $ECHO_N "(cached) $ECHO_C" >&6
3489 – else
3490 –
3491 – cat >conftest.$ac_ext <<_ACEOF
3492 –
3493 – program main
3494 –
3495 –
3496 – end program main
3497 –
3498 – _ACEOF
3499 – rm -f conftest.$ac_objext
3500 – if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3501 –  (eval $ac_compile) 2>conftest.er1
3502 –  ac_status=$?
3503 –  grep -v '^ *+' conftest.er1 >conftest.err
3504 –  rm -f conftest.er1
3505 –  cat conftest.err >&5
3506 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3507 –  (exit $ac_status); } &&
3508 –         { ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
3509 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3510 –  (eval $ac_try) 2>&5
3511 –  ac_status=$?
3512 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3513 –  (exit $ac_status); }; } &&
3514 –         { ac_try='test -s conftest.$ac_objext'
3515 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3516 –  (eval $ac_try) 2>&5
3517 –  ac_status=$?
3518 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3519 –  (exit $ac_status); }; }; then
3520 –  ac_cv_prog_f90_v=
3521 – # Try some options frequently used verbose output
3522 – for ac_verb in -v -verbose --verbose -V -\#\#\#; do
3523 –  ac_ext=f90
3524 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3525 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3526 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3527 –
3528 – cat >conftest.$ac_ext <<_ACEOF
3529 –
3530 – program main
3531 –
3532 –
3533 – end program main
3534 –
3535 – _ACEOF
3536 –
3537 – # Compile and link our simple test program by passing a flag (argument
3538 – # 1 to this macro) to the Fortran 90 compiler in order to get
3539 – # "verbose" output that we can then parse for the Fortran 90 linker
3540 – # flags.
3541 – ac_save_F90FLAGS=$F90FLAGS
3542 – F90FLAGS="$F90FLAGS $ac_verb"
3543 –
3544 – (eval echo $as_me:3544: \"$ac_link\") >&5
3545 – ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3546 – echo "$ac_f90_v_output" >&5
3547 – F90FLAGS=$ac_save_F90FLAGS
3548 –
3549 – rm -f conftest.*
3550 – ac_ext=f90
3551 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3552 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3553 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3554 –
3555 – # If we are using xlf then replace all the commas with spaces.
3556 – if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3557 –  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3268   fi
3559 –
3560 – # If we are using Cray Fortran then delete quotes.
3561 – # Use "\"" instead of '"' for font-lock-mode.
3562 – # FIXME: a more general fix for quoted arguments with spaces?
3563 – if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3564 –  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3269   fi
3270 <  # look for -l* and *.a constructs in the output
3271 <  for ac_arg in $ac_f90_v_output; do
3272 <     case $ac_arg in
3273 <        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
3570 <          ac_cv_prog_f90_v=$ac_verb
3571 <          break 2 ;;
3572 <     esac
3573 <  done
3574 < done
3575 < if test -z "$ac_cv_prog_f90_v"; then
3576 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
3577 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
3578 < fi
3270 > RANLIB=$ac_cv_prog_RANLIB
3271 > if test -n "$RANLIB"; then
3272 >  echo "$as_me:$LINENO: result: $RANLIB" >&5
3273 > echo "${ECHO_T}$RANLIB" >&6
3274   else
3275 <  echo "$as_me: failed program was:" >&5
3276 < sed 's/^/| /' conftest.$ac_ext >&5
3582 <
3583 < { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
3584 < echo "$as_me: WARNING: compilation failed" >&2;}
3275 >  echo "$as_me:$LINENO: result: no" >&5
3276 > echo "${ECHO_T}no" >&6
3277   fi
3586 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3278  
3279   fi
3280 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
3281 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
3282 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
3283 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
3284 < if test "${ac_cv_flibs+set}" = set; then
3280 > if test -z "$ac_cv_prog_RANLIB"; then
3281 >  ac_ct_RANLIB=$RANLIB
3282 >  # Extract the first word of "ranlib", so it can be a program name with args.
3283 > set dummy ranlib; ac_word=$2
3284 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3285 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3286 > if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3287    echo $ECHO_N "(cached) $ECHO_C" >&6
3288   else
3289 <  if test "x$F90LIBS" != "x"; then
3290 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
3289 >  if test -n "$ac_ct_RANLIB"; then
3290 >  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3291   else
3292 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3293 + for as_dir in $PATH
3294 + do
3295 +  IFS=$as_save_IFS
3296 +  test -z "$as_dir" && as_dir=.
3297 +  for ac_exec_ext in '' $ac_executable_extensions; do
3298 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3299 +    ac_cv_prog_ac_ct_RANLIB="ranlib"
3300 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3301 +    break 2
3302 +  fi
3303 + done
3304 + done
3305  
3306 < ac_ext=f90
3307 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3308 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3309 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3306 >  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3307 > fi
3308 > fi
3309 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3310 > if test -n "$ac_ct_RANLIB"; then
3311 >  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3312 > echo "${ECHO_T}$ac_ct_RANLIB" >&6
3313 > else
3314 >  echo "$as_me:$LINENO: result: no" >&5
3315 > echo "${ECHO_T}no" >&6
3316 > fi
3317  
3318 < cat >conftest.$ac_ext <<_ACEOF
3318 >  RANLIB=$ac_ct_RANLIB
3319 > else
3320 >  RANLIB="$ac_cv_prog_RANLIB"
3321 > fi
3322  
3607 – program main
3323  
3324 +   # Extract the first word of "perl", so it can be a program name with args.
3325 + set dummy perl; ac_word=$2
3326 + echo "$as_me:$LINENO: checking for $ac_word" >&5
3327 + echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3328 + if test "${ac_cv_path_PERLINTERP+set}" = set; then
3329 +  echo $ECHO_N "(cached) $ECHO_C" >&6
3330 + else
3331 +  case $PERLINTERP in
3332 +  [\\/]* | ?:[\\/]*)
3333 +  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
3334 +  ;;
3335 +  *)
3336 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3337 + for as_dir in $PATH
3338 + do
3339 +  IFS=$as_save_IFS
3340 +  test -z "$as_dir" && as_dir=.
3341 +  for ac_exec_ext in '' $ac_executable_extensions; do
3342 +  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3343 +    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
3344 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3345 +    break 2
3346 +  fi
3347 + done
3348 + done
3349  
3350 < end program main
3351 <
3352 < _ACEOF
3613 <
3614 < # Compile and link our simple test program by passing a flag (argument
3615 < # 1 to this macro) to the Fortran 90 compiler in order to get
3616 < # "verbose" output that we can then parse for the Fortran 90 linker
3617 < # flags.
3618 < ac_save_F90FLAGS=$F90FLAGS
3619 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
3620 <
3621 < (eval echo $as_me:3621: \"$ac_link\") >&5
3622 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3623 < echo "$ac_f90_v_output" >&5
3624 < F90FLAGS=$ac_save_F90FLAGS
3625 <
3626 < rm -f conftest.*
3627 < ac_ext=f90
3628 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3629 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3630 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3631 <
3632 < # If we are using xlf then replace all the commas with spaces.
3633 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
3634 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
3350 >  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
3351 >  ;;
3352 > esac
3353   fi
3354 + PERLINTERP=$ac_cv_path_PERLINTERP
3355  
3356 < # If we are using Cray Fortran then delete quotes.
3357 < # Use "\"" instead of '"' for font-lock-mode.
3358 < # FIXME: a more general fix for quoted arguments with spaces?
3359 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3360 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3356 > if test -n "$PERLINTERP"; then
3357 >  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
3358 > echo "${ECHO_T}$PERLINTERP" >&6
3359 > else
3360 >  echo "$as_me:$LINENO: result: no" >&5
3361 > echo "${ECHO_T}no" >&6
3362   fi
3363  
3364 < ac_cv_f90libs=
3364 >   ac_cv_path_perlinterp="$PERLINTERP"
3365 >   _sHpB='#!'
3366  
3646 – # Save positional arguments (if any)
3647 – ac_save_positional="$@"
3367  
3368 < set X $ac_f90_v_output
3368 > # Check whether --with-perl-shebang or --without-perl-shebang was given.
3369 > if test "${with_perl_shebang+set}" = set; then
3370 >  withval="$with_perl_shebang"
3371 >  opt_perl_shebang="$withval"
3372 > else
3373 >                opt_perl_shebang="not_set"
3374 > fi;
3375 >   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
3376 > echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
3377 > if test "${ax_cv_opt_perl_shebang+set}" = set; then
3378 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3379 > else
3380 >   case "$opt_perl_shebang" in
3381 >                      not_set  ) ax_cv_opt_perl_shebang=''
3382 >                               ;;
3383 >                         *     )
3384 >        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
3385 >                    esac
3386 >
3387 > fi
3388 > echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
3389 > echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
3390 >   if test "A$ax_cv_opt_perl_shebang" != "A"
3391 >     then
3392 >       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
3393 >       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3394 >              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
3395 > echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
3396 >
3397 > # Automatic detection of sharpbang formula starts here
3398 >     else
3399 >   _somian_shbangperl=`$PERLINTERP -V:startperl`
3400 >   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
3401 >   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
3402 > echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
3403 > if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
3404 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3405 > else
3406 >  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
3407 >        if test "x$_somian_kspb_perl" == x
3408 >          then _somian_ksbp_warn_empty='durnit'
3409 >          else
3410 >          case "A$_somian_kspb_perl" in
3411 >                 A#!*perl* )
3412 >           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
3413 >                        ;;
3414 >                     A*    )  _somian_ksbp_warn_defau='trouble'
3415 >                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
3416 >          esac
3417 >        fi
3418 >
3419 > fi
3420 > echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
3421 > echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
3422 > # The above prints Checking ... result message to user.
3423 >   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
3424 >
3425 >    if test A${_somian_ksbp_warn_empty+set} == Aset
3426 >      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
3427 > echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
3428 >    fi
3429 > # Inform user after printing result value
3430 >    if test A${_somian_ksbp_warn_defau+set} == Aset
3431 >      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
3432 > echo "$as_me: Maybe Not good -" >&6;}
3433 >           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
3434 > echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
3435 >      else { echo "$as_me:$LINENO: OK Good result - " >&5
3436 > echo "$as_me: OK Good result - " >&6;}
3437 >           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
3438 > echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
3439 >    fi
3440 >  fi
3441 >
3442 > # Find a good install program.  We prefer a C program (faster),
3443 > # so one script is as good as another.  But avoid the broken or
3444 > # incompatible versions:
3445 > # SysV /etc/install, /usr/sbin/install
3446 > # SunOS /usr/etc/install
3447 > # IRIX /sbin/install
3448 > # AIX /bin/install
3449 > # AmigaOS /C/install, which installs bootblocks on floppy discs
3450 > # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
3451 > # AFS /usr/afsws/bin/install, which mishandles nonexistent args
3452 > # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
3453 > # OS/2's system install, which has a completely different semantic
3454 > # ./install, which can be erroneously created by make from ./install.sh.
3455 > echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
3456 > echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
3457 > if test -z "$INSTALL"; then
3458 > if test "${ac_cv_path_install+set}" = set; then
3459 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3460 > else
3461 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3462 > for as_dir in $PATH
3463 > do
3464 >  IFS=$as_save_IFS
3465 >  test -z "$as_dir" && as_dir=.
3466 >  # Account for people who put trailing slashes in PATH elements.
3467 > case $as_dir/ in
3468 >  ./ | .// | /cC/* | \
3469 >  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
3470 >  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
3471 >  /usr/ucb/* ) ;;
3472 >  *)
3473 >    # OSF1 and SCO ODT 3.0 have their own names for install.
3474 >    # Don't use installbsd from OSF since it installs stuff as root
3475 >    # by default.
3476 >    for ac_prog in ginstall scoinst install; do
3477 >      for ac_exec_ext in '' $ac_executable_extensions; do
3478 >        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
3479 >          if test $ac_prog = install &&
3480 >            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3481 >            # AIX install.  It has an incompatible calling convention.
3482 >            :
3483 >          elif test $ac_prog = install &&
3484 >            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
3485 >            # program-specific install script used by HP pwplus--don't use.
3486 >            :
3487 >          else
3488 >            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
3489 >            break 3
3490 >          fi
3491 >        fi
3492 >      done
3493 >    done
3494 >    ;;
3495 > esac
3496 > done
3497 >
3498 >
3499 > fi
3500 >  if test "${ac_cv_path_install+set}" = set; then
3501 >    INSTALL=$ac_cv_path_install
3502 >  else
3503 >    # As a last resort, use the slow shell script.  We don't cache a
3504 >    # path for INSTALL within a source directory, because that will
3505 >    # break other packages using the cache if that directory is
3506 >    # removed, or if the path is relative.
3507 >    INSTALL=$ac_install_sh
3508 >  fi
3509 > fi
3510 > echo "$as_me:$LINENO: result: $INSTALL" >&5
3511 > echo "${ECHO_T}$INSTALL" >&6
3512 >
3513 > # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
3514 > # It thinks the first close brace ends the variable substitution.
3515 > test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
3516 >
3517 > test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
3518 >
3519 > test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
3520 >
3521 > case "x$INSTALL" in
3522 >   x/*) ;;
3523 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
3524 > esac
3525 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
3526 > # Extract the first word of "ar", so it can be a program name with args.
3527 > set dummy ar; ac_word=$2
3528 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3529 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3530 > if test "${ac_cv_prog_AR+set}" = set; then
3531 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3532 > else
3533 >  if test -n "$AR"; then
3534 >  ac_cv_prog_AR="$AR" # Let the user override the test.
3535 > else
3536 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3537 > for as_dir in $PATH
3538 > do
3539 >  IFS=$as_save_IFS
3540 >  test -z "$as_dir" && as_dir=.
3541 >  for ac_exec_ext in '' $ac_executable_extensions; do
3542 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3543 >    ac_cv_prog_AR="ar"
3544 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3545 >    break 2
3546 >  fi
3547 > done
3548 > done
3549 >
3550 >  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
3551 > fi
3552 > fi
3553 > AR=$ac_cv_prog_AR
3554 > if test -n "$AR"; then
3555 >  echo "$as_me:$LINENO: result: $AR" >&5
3556 > echo "${ECHO_T}$AR" >&6
3557 > else
3558 >  echo "$as_me:$LINENO: result: no" >&5
3559 > echo "${ECHO_T}no" >&6
3560 > fi
3561 >
3562 > if test "$AR" = "NONE"; then
3563 >  cat >confcache <<\_ACEOF
3564 > # This file is a shell script that caches the results of configure
3565 > # tests run on this system so they can be shared between configure
3566 > # scripts and configure runs, see configure's option --config-cache.
3567 > # It is not useful on other systems.  If it contains results you don't
3568 > # want to keep, you may remove or edit it.
3569 > #
3570 > # config.status only pays attention to the cache file if you give it
3571 > # the --recheck option to rerun configure.
3572 > #
3573 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
3574 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
3575 > # following values.
3576 >
3577 > _ACEOF
3578 >
3579 > # The following way of writing the cache mishandles newlines in values,
3580 > # but we know of no workaround that is simple, portable, and efficient.
3581 > # So, don't put newlines in cache variables' values.
3582 > # Ultrix sh set writes to stderr and can't be redirected directly,
3583 > # and sets the high bit in the cache file unless we assign to the vars.
3584 > {
3585 >  (set) 2>&1 |
3586 >    case `(ac_space=' '; set | grep ac_space) 2>&1` in
3587 >    *ac_space=\ *)
3588 >      # `set' does not quote correctly, so add quotes (double-quote
3589 >      # substitution turns \\\\ into \\, and sed turns \\ into \).
3590 >      sed -n \
3591 >        "s/'/'\\\\''/g;
3592 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
3593 >      ;;
3594 >    *)
3595 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
3596 >      sed -n \
3597 >        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
3598 >      ;;
3599 >    esac;
3600 > } |
3601 >  sed '
3602 >     t clear
3603 >     : clear
3604 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
3605 >     t end
3606 >     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
3607 >     : end' >>confcache
3608 > if diff $cache_file confcache >/dev/null 2>&1; then :; else
3609 >  if test -w $cache_file; then
3610 >    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
3611 >    cat confcache >$cache_file
3612 >  else
3613 >    echo "not updating unwritable cache $cache_file"
3614 >  fi
3615 > fi
3616 > rm -f confcache
3617 >  exit 1
3618 > fi
3619 > # Extract the first word of "ps", so it can be a program name with args.
3620 > set dummy ps; ac_word=$2
3621 > echo "$as_me:$LINENO: checking for $ac_word" >&5
3622 > echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3623 > if test "${ac_cv_path_PS+set}" = set; then
3624 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3625 > else
3626 >  case $PS in
3627 >  [\\/]* | ?:[\\/]*)
3628 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
3629 >  ;;
3630 >  *)
3631 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3632 > for as_dir in $PATH
3633 > do
3634 >  IFS=$as_save_IFS
3635 >  test -z "$as_dir" && as_dir=.
3636 >  for ac_exec_ext in '' $ac_executable_extensions; do
3637 >  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3638 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
3639 >    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3640 >    break 2
3641 >  fi
3642 > done
3643 > done
3644 >
3645 >  ;;
3646 > esac
3647 > fi
3648 > PS=$ac_cv_path_PS
3649 >
3650 > if test -n "$PS"; then
3651 >  echo "$as_me:$LINENO: result: $PS" >&5
3652 > echo "${ECHO_T}$PS" >&6
3653 > else
3654 >  echo "$as_me:$LINENO: result: no" >&5
3655 > echo "${ECHO_T}no" >&6
3656 > fi
3657 >
3658 > echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
3659 > echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
3660 > if test "${ac_cv_prog_ps_syntax+set}" = set; then
3661 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3662 > else
3663 >
3664 >        if $PS ax -o rss > /dev/null 2>&1; then
3665 >                ac_cv_prog_ps_ax=yes
3666 >        else
3667 >                ac_cv_prog_ps_ax=no
3668 >        fi
3669 >        if $PS -ef -o rss > /dev/null 2>&1; then
3670 >                ac_cv_prog_ps_ef=yes
3671 >        else
3672 >                ac_cv_prog_ps_ef=no
3673 >        fi
3674 >        if test "$ac_cv_prog_ps_ax" = yes; then
3675 >                ac_cv_prog_ps_syntax=BSD
3676 >        else
3677 >                if test "$ac_cv_prog_ps_ef" = yes; then
3678 >                        ac_cv_prog_ps_syntax=POSIX
3679 >                else
3680 >                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
3681 > echo "$as_me: error: Could not determine ps syntax" >&2;}
3682 >   { (exit 1); exit 1; }; }
3683 >                fi
3684 >        fi
3685 >
3686 > fi
3687 > echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
3688 > echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
3689 >
3690 > cat >>confdefs.h <<_ACEOF
3691 > #define PSCOMMAND $PS
3692 > _ACEOF
3693 >
3694 > if test "$ac_cv_prog_ps_syntax" = BSD; then
3695 >
3696 > cat >>confdefs.h <<\_ACEOF
3697 > #define PSTYPE_IS_BSD 1
3698 > _ACEOF
3699 >
3700 > else
3701 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3702 >
3703 > cat >>confdefs.h <<\_ACEOF
3704 > #define PSTYPE_IS_POSIX 1
3705 > _ACEOF
3706 >
3707 >   else
3708 >       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
3709 > echo "$as_me: error: Unknown ps syntax type!" >&2;}
3710 >   { (exit 1); exit 1; }; }
3711 >   fi
3712 > fi
3713 >
3714 > ac_ext=${FC_SRCEXT-f}
3715 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3716 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3717 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3718 >
3719 >
3720 > echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
3721 > echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6
3722 > if test "${ac_cv_fc_srcext_F90+set}" = set; then
3723 >  echo $ECHO_N "(cached) $ECHO_C" >&6
3724 > else
3725 >  ac_ext=F90
3726 > ac_fc_srcext_FCFLAGS_SRCEXT_save=$FCFLAGS_SRCEXT
3727 > FCFLAGS_SRCEXT=""
3728 > ac_cv_fc_srcext_F90=unknown
3729 > for ac_flag in none -qsuffix=f=F90 -Tf; do
3730 >  test "x$ac_flag" != xnone && FCFLAGS_SRCEXT="$ac_flag"
3731 >  cat >conftest.$ac_ext <<_ACEOF
3732 >      program main
3733 >
3734 >      end
3735 > _ACEOF
3736 > rm -f conftest.$ac_objext
3737 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3738 >  (eval $ac_compile) 2>conftest.er1
3739 >  ac_status=$?
3740 >  grep -v '^ *+' conftest.er1 >conftest.err
3741 >  rm -f conftest.er1
3742 >  cat conftest.err >&5
3743 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3744 >  (exit $ac_status); } &&
3745 >         { ac_try='test -z "$ac_fc_werror_flag"
3746 >                         || test ! -s conftest.err'
3747 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3748 >  (eval $ac_try) 2>&5
3749 >  ac_status=$?
3750 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3751 >  (exit $ac_status); }; } &&
3752 >         { ac_try='test -s conftest.$ac_objext'
3753 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3754 >  (eval $ac_try) 2>&5
3755 >  ac_status=$?
3756 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3757 >  (exit $ac_status); }; }; then
3758 >  ac_cv_fc_srcext_F90=$ac_flag; break
3759 > else
3760 >  echo "$as_me: failed program was:" >&5
3761 > sed 's/^/| /' conftest.$ac_ext >&5
3762 >
3763 > fi
3764 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3765 > done
3766 > rm -f conftest.$ac_objext conftest.F90
3767 > FCFLAGS_SRCEXT=$ac_fc_srcext_FCFLAGS_SRCEXT_save
3768 >
3769 > fi
3770 > echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
3771 > echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6
3772 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
3773 >  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
3774 > echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
3775 >   { (exit 1); exit 1; }; }
3776 > else
3777 >  FC_SRCEXT=F90
3778 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
3779 >    FCFLAGS_SRCEXT=""
3780 >    FCFLAGS_F90=""
3781 >  else
3782 >    FCFLAGS_SRCEXT=$ac_cv_fc_srcext_F90
3783 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
3784 >  fi
3785 >
3786 >
3787 > fi
3788 >
3789 >
3790 >
3791 >
3792 >
3793 > # Try to determine native compiler flags that allow us to use F90 suffix
3794 > # for preprocessed f90 source.
3795 >
3796 > if test "$ac_test_PREPFLAG" != "set"; then
3797 >  PREPFLAG=""
3798 >  case "${host_cpu}-${host_os}" in
3799 >
3800 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3801 >                    PREPFLAG="-fpp1 "
3802 >                fi;;
3803 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3804 >                    PREPFLAG="-qsuffix=cpp=F90 "
3805 >                fi;;
3806 >  *darwin*)
3807 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3808 >                PREPFLAG="-qsuffix=cpp=F90 "
3809 >        fi;;
3810 >  esac
3811 >
3812 >  if test -z "$PREPFLAG"; then
3813 >        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
3814 > echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
3815 >        PREPFLAG=""
3816 >  fi
3817 >
3818 >  echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
3819 > echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3820 >
3821 >
3822 >  ac_ext=${FC_SRCEXT-f}
3823 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3824 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3825 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3826 >
3827 >  ac_save_ext=$ac_ext
3828 >  ac_ext=F90
3829 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3830 >
3831 >  if test "$PREPFLAG"; then
3832 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3833 > fi
3834 >
3835 >    cat >conftest.$ac_ext <<_ACEOF
3836 >
3837 >
3838 > program conftest
3839 >  integer :: i
3840 >  i = 1
3841 > end program conftest
3842 >
3843 > _ACEOF
3844 > rm -f conftest.$ac_objext
3845 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3846 >  (eval $ac_compile) 2>conftest.er1
3847 >  ac_status=$?
3848 >  grep -v '^ *+' conftest.er1 >conftest.err
3849 >  rm -f conftest.er1
3850 >  cat conftest.err >&5
3851 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3852 >  (exit $ac_status); } &&
3853 >         { ac_try='test -z "$ac_fc_werror_flag"
3854 >                         || test ! -s conftest.err'
3855 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3856 >  (eval $ac_try) 2>&5
3857 >  ac_status=$?
3858 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3859 >  (exit $ac_status); }; } &&
3860 >         { ac_try='test -s conftest.$ac_objext'
3861 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3862 >  (eval $ac_try) 2>&5
3863 >  ac_status=$?
3864 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3865 >  (exit $ac_status); }; }; then
3866 >  prepflagworks=1
3867 > else
3868 >  echo "$as_me: failed program was:" >&5
3869 > sed 's/^/| /' conftest.$ac_ext >&5
3870 >
3871 > prepflagworks=0
3872 > fi
3873 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3874 >
3875 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3876 >  ac_ext=$ac_save_ext
3877 >  ac_ext=${FC_SRCEXT-f}
3878 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3879 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3880 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3881 >
3882 >
3883 >  if test "$prepflagworks" = 1; then
3884 >    echo "$as_me:$LINENO: result: yes" >&5
3885 > echo "${ECHO_T}yes" >&6
3886 >    FCFLAGS_SRCEXT="${PREPFLAG}"
3887 >
3888 >  else
3889 >    echo "$as_me:$LINENO: result: no" >&5
3890 > echo "${ECHO_T}no" >&6
3891 >    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
3892 > echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
3893 >   { (exit 1); exit 1; }; }
3894 >  fi
3895 > fi
3896 >
3897 >
3898 >
3899 >
3900 >
3901 > # Try to determine native compiler flags that allow us to use F90 suffix
3902 > # for preprocessed f90 source with -D type defines
3903 >
3904 > if test "$ac_test_PREPDEFFLAG" != "set"; then
3905 >  PREPDEFFLAG=""
3906 >  case "${host_cpu}-${host_os}" in
3907 >
3908 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3909 >                    PREPDEFFLAG=" "
3910 >                fi;;
3911 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3912 >                    PREPDEFFLAG="-WF,"
3913 >                fi;;
3914 >  *darwin*)
3915 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3916 >                PREPDEFFLAG="-WF,"
3917 >        fi;;
3918 >  esac
3919 >
3920 >  if test -z "$PREPDEFFLAG"; then
3921 >        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
3922 > echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
3923 >        PREPDEFFLAG=" "
3924 >  fi
3925 >
3926 >  echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
3927 > echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3928 >
3929 >
3930 >  ac_ext=${FC_SRCEXT-f}
3931 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3932 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3933 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3934 >
3935 >  ac_save_ext=$ac_ext
3936 >  ac_ext=F90
3937 >  ac_save_FCFLAGS=$FCFLAGS
3938 >
3939 >  if test "$PREPDEFFLAG"; then
3940 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3941 > fi
3942 >
3943 >    cat >conftest.$ac_ext <<_ACEOF
3944 >
3945 >
3946 > program conftest
3947 >  integer :: i
3948 > #ifdef TEST
3949 >  i = 1
3950 > #else
3951 >  choke me
3952 > #endif
3953 > end program conftest
3954 >
3955 > _ACEOF
3956 > rm -f conftest.$ac_objext
3957 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3958 >  (eval $ac_compile) 2>conftest.er1
3959 >  ac_status=$?
3960 >  grep -v '^ *+' conftest.er1 >conftest.err
3961 >  rm -f conftest.er1
3962 >  cat conftest.err >&5
3963 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3964 >  (exit $ac_status); } &&
3965 >         { ac_try='test -z "$ac_fc_werror_flag"
3966 >                         || test ! -s conftest.err'
3967 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3968 >  (eval $ac_try) 2>&5
3969 >  ac_status=$?
3970 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3971 >  (exit $ac_status); }; } &&
3972 >         { ac_try='test -s conftest.$ac_objext'
3973 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3974 >  (eval $ac_try) 2>&5
3975 >  ac_status=$?
3976 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3977 >  (exit $ac_status); }; }; then
3978 >  prepdefflagworks=1
3979 > else
3980 >  echo "$as_me: failed program was:" >&5
3981 > sed 's/^/| /' conftest.$ac_ext >&5
3982 >
3983 > prepdefflagworks=0
3984 > fi
3985 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3986 >
3987 >  FCFLAGS=$ac_save_FCFLAGS
3988 >  ac_ext=$ac_save_ext
3989 >  ac_ext=${FC_SRCEXT-f}
3990 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
3991 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
3992 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3993 >
3994 >
3995 >  if test "$prepdefflagworks" = 1; then
3996 >    echo "$as_me:$LINENO: result: yes" >&5
3997 > echo "${ECHO_T}yes" >&6
3998 >
3999 >  else
4000 >    echo "$as_me:$LINENO: result: no" >&5
4001 > echo "${ECHO_T}no" >&6
4002 >    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
4003 > echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
4004 >   { (exit 1); exit 1; }; }
4005 >  fi
4006 > fi
4007 >
4008 > ac_ext=${FC_SRCEXT-f}
4009 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4010 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4011 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4012 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4013 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4014 > if test "${ac_cv_prog_fc_v+set}" = set; then
4015 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4016 > else
4017 >  cat >conftest.$ac_ext <<_ACEOF
4018 >      program main
4019 >
4020 >      end
4021 > _ACEOF
4022 > rm -f conftest.$ac_objext
4023 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4024 >  (eval $ac_compile) 2>conftest.er1
4025 >  ac_status=$?
4026 >  grep -v '^ *+' conftest.er1 >conftest.err
4027 >  rm -f conftest.er1
4028 >  cat conftest.err >&5
4029 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4030 >  (exit $ac_status); } &&
4031 >         { ac_try='test -z "$ac_fc_werror_flag"
4032 >                         || test ! -s conftest.err'
4033 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4034 >  (eval $ac_try) 2>&5
4035 >  ac_status=$?
4036 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4037 >  (exit $ac_status); }; } &&
4038 >         { ac_try='test -s conftest.$ac_objext'
4039 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4040 >  (eval $ac_try) 2>&5
4041 >  ac_status=$?
4042 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4043 >  (exit $ac_status); }; }; then
4044 >  ac_cv_prog_fc_v=
4045 > # Try some options frequently used verbose output
4046 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4047 >  cat >conftest.$ac_ext <<_ACEOF
4048 >      program main
4049 >
4050 >      end
4051 > _ACEOF
4052 >
4053 > # Compile and link our simple test program by passing a flag (argument
4054 > # 1 to this macro) to the Fortran compiler in order to get
4055 > # "verbose" output that we can then parse for the Fortran linker
4056 > # flags.
4057 > ac_save_FFLAGS=$FCFLAGS
4058 > FCFLAGS="$FCFLAGS $ac_verb"
4059 > (eval echo $as_me:4059: \"$ac_link\") >&5
4060 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4061 > echo "$ac_fc_v_output" >&5
4062 > FCFLAGS=$ac_save_FFLAGS
4063 >
4064 > rm -f conftest*
4065 >
4066 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4067 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4068 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4069 > ac_fc_v_output="`echo $ac_fc_v_output |
4070 >        grep 'LPATH is:' |
4071 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4072 >
4073 > case $ac_fc_v_output in
4074 >  # If we are using xlf then replace all the commas with spaces.
4075 >  *xlfentry*)
4076 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4077 >
4078 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4079 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4080 >  *mGLOB_options_string*)
4081 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4082 >
4083 >  # If we are using Cray Fortran then delete quotes.
4084 >  # Use "\"" instead of '"' for font-lock-mode.
4085 >  # FIXME: a more general fix for quoted arguments with spaces?
4086 >  *cft90*)
4087 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4088 > esac
4089 >
4090 >
4091 >  # look for -l* and *.a constructs in the output
4092 >  for ac_arg in $ac_fc_v_output; do
4093 >     case $ac_arg in
4094 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4095 >          ac_cv_prog_fc_v=$ac_verb
4096 >          break 2 ;;
4097 >     esac
4098 >  done
4099 > done
4100 > if test -z "$ac_cv_prog_fc_v"; then
4101 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4102 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4103 > fi
4104 > else
4105 >  echo "$as_me: failed program was:" >&5
4106 > sed 's/^/| /' conftest.$ac_ext >&5
4107 >
4108 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4109 > echo "$as_me: WARNING: compilation failed" >&2;}
4110 > fi
4111 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4112 >
4113 > fi
4114 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4115 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4116 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4117 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4118 > if test "${ac_cv_fc_libs+set}" = set; then
4119 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4120 > else
4121 >  if test "x$FCLIBS" != "x"; then
4122 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4123 > else
4124 >
4125 > cat >conftest.$ac_ext <<_ACEOF
4126 >      program main
4127 >
4128 >      end
4129 > _ACEOF
4130 >
4131 > # Compile and link our simple test program by passing a flag (argument
4132 > # 1 to this macro) to the Fortran compiler in order to get
4133 > # "verbose" output that we can then parse for the Fortran linker
4134 > # flags.
4135 > ac_save_FFLAGS=$FCFLAGS
4136 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4137 > (eval echo $as_me:4137: \"$ac_link\") >&5
4138 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4139 > echo "$ac_fc_v_output" >&5
4140 > FCFLAGS=$ac_save_FFLAGS
4141 >
4142 > rm -f conftest*
4143 >
4144 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4145 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4146 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4147 > ac_fc_v_output="`echo $ac_fc_v_output |
4148 >        grep 'LPATH is:' |
4149 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4150 >
4151 > case $ac_fc_v_output in
4152 >  # If we are using xlf then replace all the commas with spaces.
4153 >  *xlfentry*)
4154 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4155 >
4156 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4157 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4158 >  *mGLOB_options_string*)
4159 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4160 >
4161 >  # If we are using Cray Fortran then delete quotes.
4162 >  # Use "\"" instead of '"' for font-lock-mode.
4163 >  # FIXME: a more general fix for quoted arguments with spaces?
4164 >  *cft90*)
4165 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4166 > esac
4167 >
4168 >
4169 >
4170 > ac_cv_fc_libs=
4171 >
4172 > # Save positional arguments (if any)
4173 > ac_save_positional="$@"
4174 >
4175 > set X $ac_fc_v_output
4176   while test $# != 1; do
4177    shift
4178    ac_arg=$1
4179    case $ac_arg in
4180          [\\/]*.a | ?:[\\/]*.a)
4181              ac_exists=false
4182 <  for ac_i in $ac_cv_f90libs; do
4182 >  for ac_i in $ac_cv_fc_libs; do
4183      if test x"$ac_arg" = x"$ac_i"; then
4184        ac_exists=true
4185        break
# Line 3663 | Line 4189 | else
4189    if test x"$ac_exists" = xtrue; then
4190    :
4191   else
4192 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4192 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4193   fi
4194  
4195            ;;
4196          -bI:*)
4197              ac_exists=false
4198 <  for ac_i in $ac_cv_f90libs; do
4198 >  for ac_i in $ac_cv_fc_libs; do
4199      if test x"$ac_arg" = x"$ac_i"; then
4200        ac_exists=true
4201        break
# Line 3681 | Line 4207 | else
4207   else
4208    if test "$ac_compiler_gnu" = yes; then
4209    for ac_link_opt in $ac_arg; do
4210 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4210 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4211    done
4212   else
4213 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4213 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4214   fi
4215   fi
4216  
4217            ;;
4218            # Ignore these flags.
4219 <        -lang* | -lcrt[012].o | -lc | -lgcc | -LANG:=*)
4219 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
4220            ;;
4221          -lkernel32)
4222 <          test x"$CYGWIN" != xyes && ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4222 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4223            ;;
4224          -[LRuY])
4225            # These flags, when seen by themselves, take an argument.
4226            # We remove the space between option and argument and re-iterate
4227            # unless we find an empty arg or a new option (starting with -)
4228            case $2 in
4229 <             "" | -*);;
4230 <             *)
4229 >             "" | -*);;
4230 >             *)
4231                  ac_arg="$ac_arg$2"
3706 –
4232                  shift; shift
4233                  set X $ac_arg "$@"
4234                  ;;
# Line 3712 | Line 4237 | fi
4237          -YP,*)
4238            for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
4239                ac_exists=false
4240 <  for ac_i in $ac_cv_f90libs; do
4240 >  for ac_i in $ac_cv_fc_libs; do
4241      if test x"$ac_j" = x"$ac_i"; then
4242        ac_exists=true
4243        break
# Line 3723 | Line 4248 | else
4248    :
4249   else
4250    ac_arg="$ac_arg $ac_j"
4251 <                             ac_cv_f90libs="$ac_cv_f90libs $ac_j"
4251 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
4252   fi
4253  
4254            done
4255            ;;
4256          -[lLR]*)
4257              ac_exists=false
4258 <  for ac_i in $ac_cv_f90libs; do
4258 >  for ac_i in $ac_cv_fc_libs; do
4259      if test x"$ac_arg" = x"$ac_i"; then
4260        ac_exists=true
4261        break
# Line 3740 | Line 4265 | else
4265    if test x"$ac_exists" = xtrue; then
4266    :
4267   else
4268 <  ac_cv_f90libs="$ac_cv_f90libs $ac_arg"
4268 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
4269   fi
4270  
4271            ;;
# Line 3755 | Line 4280 | case `(uname -sr) 2>/dev/null` in
4280   # must begin with a "/").
4281   case `(uname -sr) 2>/dev/null` in
4282     "SunOS 5"*)
4283 <      ac_ld_run_path=`echo $ac_f90_v_output |
4283 >      ac_ld_run_path=`echo $ac_fc_v_output |
4284                          sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
4285        test "x$ac_ld_run_path" != x &&
3761 –
4286          if test "$ac_compiler_gnu" = yes; then
4287    for ac_link_opt in $ac_ld_run_path; do
4288 <    ac_cv_f90libs="$ac_cv_f90libs -Xlinker $ac_link_opt"
4288 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
4289    done
4290   else
4291 <  ac_cv_f90libs="$ac_cv_f90libs $ac_ld_run_path"
4291 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
4292   fi
4293        ;;
4294   esac
4295 < fi # test "x$F90LIBS" = "x"
4295 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
4296  
4297   fi
4298 < echo "$as_me:$LINENO: result: $ac_cv_flibs" >&5
4299 < echo "${ECHO_T}$ac_cv_flibs" >&6
4300 < F90LIBS="$ac_cv_f90libs"
4298 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
4299 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
4300 > FCLIBS="$ac_cv_fc_libs"
4301  
3778 – ac_ext=f90
3779 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3780 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3781 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4302  
4303 + ac_ext=${FC_SRCEXT-f}
4304 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4305 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4306 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4307  
4308 < echo "$as_me:$LINENO: checking for Fortran 90 name-mangling scheme" >&5
4309 < echo $ECHO_N "checking for Fortran 90 name-mangling scheme... $ECHO_C" >&6
4310 < if test "${ac_cv_f90_mangling+set}" = set; then
4308 >
4309 > ac_ext=${FC_SRCEXT-f}
4310 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4311 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4312 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4313 >
4314 > echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
4315 > echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6
4316 > if test "${ac_cv_fc_dummy_main+set}" = set; then
4317    echo $ECHO_N "(cached) $ECHO_C" >&6
4318   else
4319 <  ac_ext=f90
4320 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4321 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4322 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3793 < cat >conftest.$ac_ext <<_ACEOF
3794 < subroutine foobar()
3795 < return
3796 < end
3797 < subroutine foo_bar()
3798 < return
3799 < end
3800 < _ACEOF
3801 < rm -f conftest.$ac_objext
3802 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3803 <  (eval $ac_compile) 2>conftest.er1
3804 <  ac_status=$?
3805 <  grep -v '^ *+' conftest.er1 >conftest.err
3806 <  rm -f conftest.er1
3807 <  cat conftest.err >&5
3808 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3809 <  (exit $ac_status); } &&
3810 <         { ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
3811 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3812 <  (eval $ac_try) 2>&5
3813 <  ac_status=$?
3814 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3815 <  (exit $ac_status); }; } &&
3816 <         { ac_try='test -s conftest.$ac_objext'
3817 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3818 <  (eval $ac_try) 2>&5
3819 <  ac_status=$?
3820 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3821 <  (exit $ac_status); }; }; then
3822 <  mv conftest.$ac_objext cf90_test.$ac_objext
3823 <
3824 <  ac_ext=c
4319 >  ac_fc_dm_save_LIBS=$LIBS
4320 > LIBS="$LIBS $FCLIBS"
4321 > ac_fortran_dm_var=FC_DUMMY_MAIN
4322 > ac_ext=c
4323   ac_cpp='$CPP $CPPFLAGS'
4324   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4325   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4326   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4327  
4328 <  ac_save_LIBS=$LIBS
4329 <  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
3832 <
3833 <  ac_success=no
3834 <  for ac_foobar in foobar FOOBAR; do
3835 <    for ac_underscore in "" "_"; do
3836 <      ac_func="$ac_foobar$ac_underscore"
3837 <      cat >conftest.$ac_ext <<_ACEOF
4328 > # First, try linking without a dummy main:
4329 > cat >conftest.$ac_ext <<_ACEOF
4330   /* confdefs.h.  */
4331   _ACEOF
4332   cat confdefs.h >>conftest.$ac_ext
4333   cat >>conftest.$ac_ext <<_ACEOF
4334   /* end confdefs.h.  */
4335  
4336 < /* Override any gcc2 internal prototype to avoid an error.  */
4337 < #ifdef __cplusplus
4338 < extern "C"
4336 > #ifdef FC_DUMMY_MAIN
4337 > #ifndef FC_DUMMY_MAIN_EQ_F77
4338 > #  ifdef __cplusplus
4339 >     extern "C"
4340 > #  endif
4341 >   int FC_DUMMY_MAIN() { return 1; }
4342   #endif
4343 < /* We use char because int might match the return type of a gcc2
3849 <   builtin and then its argument prototype would still apply.  */
3850 < char $ac_func ();
4343 > #endif
4344   int
4345   main ()
4346   {
4347 < $ac_func ();
4347 >
4348    ;
4349    return 0;
4350   }
# Line 3865 | Line 4358 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4358    cat conftest.err >&5
4359    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4360    (exit $ac_status); } &&
4361 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
4361 >         { ac_try='test -z "$ac_c_werror_flag"
4362 >                         || test ! -s conftest.err'
4363    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4364    (eval $ac_try) 2>&5
4365    ac_status=$?
# Line 3877 | Line 4371 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4371    ac_status=$?
4372    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4373    (exit $ac_status); }; }; then
4374 <  ac_success=yes; break 2
4374 >  ac_cv_fortran_dummy_main=none
4375   else
4376    echo "$as_me: failed program was:" >&5
4377   sed 's/^/| /' conftest.$ac_ext >&5
4378  
4379 + ac_cv_fortran_dummy_main=unknown
4380   fi
4381   rm -f conftest.err conftest.$ac_objext \
4382        conftest$ac_exeext conftest.$ac_ext
3888 –    done
3889 –  done
4383  
4384 <  if test "$ac_success" = "yes"; then
4385 <     case $ac_foobar in
4386 <        foobar)
3894 <           ac_case=lower
3895 <           ac_foo_bar=foo_bar
3896 <           ;;
3897 <        FOOBAR)
3898 <           ac_case=upper
3899 <           ac_foo_bar=FOO_BAR
3900 <           ;;
3901 <     esac
3902 <
3903 <     ac_success_extra=no
3904 <     for ac_extra in "" "_"; do
3905 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
3906 <
3907 <        cat >conftest.$ac_ext <<_ACEOF
4384 > if test $ac_cv_fortran_dummy_main = unknown; then
4385 >   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
4386 >     cat >conftest.$ac_ext <<_ACEOF
4387   /* confdefs.h.  */
4388   _ACEOF
4389   cat confdefs.h >>conftest.$ac_ext
4390   cat >>conftest.$ac_ext <<_ACEOF
4391   /* end confdefs.h.  */
4392 <
4393 < /* Override any gcc2 internal prototype to avoid an error.  */
4394 < #ifdef __cplusplus
4395 < extern "C"
4392 > #define $ac_fortran_dm_var $ac_func
4393 > #ifdef FC_DUMMY_MAIN
4394 > #ifndef FC_DUMMY_MAIN_EQ_F77
4395 > #  ifdef __cplusplus
4396 >     extern "C"
4397 > #  endif
4398 >   int FC_DUMMY_MAIN() { return 1; }
4399   #endif
4400 < /* We use char because int might match the return type of a gcc2
3919 <   builtin and then its argument prototype would still apply.  */
3920 < char $ac_func ();
4400 > #endif
4401   int
4402   main ()
4403   {
4404 < $ac_func ();
4404 >
4405    ;
4406    return 0;
4407   }
# Line 3935 | Line 4415 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4415    cat conftest.err >&5
4416    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4417    (exit $ac_status); } &&
4418 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
4418 >         { ac_try='test -z "$ac_c_werror_flag"
4419 >                         || test ! -s conftest.err'
4420    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4421    (eval $ac_try) 2>&5
4422    ac_status=$?
# Line 3947 | Line 4428 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4428    ac_status=$?
4429    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4430    (exit $ac_status); }; }; then
4431 <  ac_success_extra=yes; break
4431 >  ac_cv_fortran_dummy_main=$ac_func; break
4432   else
4433    echo "$as_me: failed program was:" >&5
4434   sed 's/^/| /' conftest.$ac_ext >&5
# Line 3955 | Line 4436 | rm -f conftest.err conftest.$ac_objext \
4436   fi
4437   rm -f conftest.err conftest.$ac_objext \
4438        conftest$ac_exeext conftest.$ac_ext
4439 <     done
4439 >   done
4440 > fi
4441 > ac_ext=${FC_SRCEXT-f}
4442 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4443 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4444 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4445 > ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
4446 > rm -f conftest*
4447 > LIBS=$ac_fc_dm_save_LIBS
4448  
4449 <     if test "$ac_success_extra" = "yes"; then
4450 <        ac_cv_f90_mangling="$ac_case case"
4451 <        if test -z "$ac_underscore"; then
4452 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4453 <        else
4454 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4449 > fi
4450 > echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
4451 > echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6
4452 > FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
4453 > if test "$FC_DUMMY_MAIN" != unknown; then
4454 >  if test $FC_DUMMY_MAIN != none; then
4455  
4456 <        fi
4457 <        if test -z "$ac_extra"; then
4458 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
3970 <        else
3971 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
3972 <        fi
3973 <      else
3974 <        ac_cv_f90_mangling="unknown"
3975 <      fi
3976 <  else
3977 <     ac_cv_f90_mangling="unknown"
4456 > cat >>confdefs.h <<_ACEOF
4457 > #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4458 > _ACEOF
4459  
4460 <  fi
4460 >  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4461  
4462 <  LIBS=$ac_save_LIBS
4463 <  ac_ext=f90
4464 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4465 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4466 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4467 <  rm -f cf90_test* conftest*
4468 < else
4469 <  echo "$as_me: failed program was:" >&5
4470 < sed 's/^/| /' conftest.$ac_ext >&5
4471 <
4472 < fi
4473 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4474 < ac_ext=f90
4475 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4476 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4477 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4478 <
4479 < fi
4480 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4481 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
4482 <
4483 <
4484 <
4485 < case $ac_cv_f90_mangling in
4486 <  "lower case, no underscore, no extra underscore")
4487 <          cat >>confdefs.h <<\_ACEOF
4488 < #define F90_FUNC(name,NAME) name
4489 < _ACEOF
4490 <
4491 <          cat >>confdefs.h <<\_ACEOF
4492 < #define F90_FUNC_(name,NAME) name
4493 < _ACEOF
4494 < ;;
4495 <  "lower case, no underscore, extra underscore")
4496 <          cat >>confdefs.h <<\_ACEOF
4497 < #define F90_FUNC(name,NAME) name
4498 < _ACEOF
4499 <
4500 <          cat >>confdefs.h <<\_ACEOF
4501 < #define F90_FUNC_(name,NAME) name ## _
4502 < _ACEOF
4503 < ;;
4504 <  "lower case, underscore, no extra underscore")
4505 <          cat >>confdefs.h <<\_ACEOF
4506 < #define F90_FUNC(name,NAME) name ## _
4507 < _ACEOF
4508 <
4509 <          cat >>confdefs.h <<\_ACEOF
4510 < #define F90_FUNC_(name,NAME) name ## _
4511 < _ACEOF
4512 < ;;
4513 <  "lower case, underscore, extra underscore")
4514 <          cat >>confdefs.h <<\_ACEOF
4515 < #define F90_FUNC(name,NAME) name ## _
4516 < _ACEOF
4517 <
4518 <          cat >>confdefs.h <<\_ACEOF
4519 < #define F90_FUNC_(name,NAME) name ## __
4520 < _ACEOF
4521 < ;;
4522 <  "upper case, no underscore, no extra underscore")
4523 <          cat >>confdefs.h <<\_ACEOF
4524 < #define F90_FUNC(name,NAME) NAME
4525 < _ACEOF
4526 <
4527 <          cat >>confdefs.h <<\_ACEOF
4528 < #define F90_FUNC_(name,NAME) NAME
4529 < _ACEOF
4530 < ;;
4531 <  "upper case, no underscore, extra underscore")
4532 <          cat >>confdefs.h <<\_ACEOF
4533 < #define F90_FUNC(name,NAME) NAME
4534 < _ACEOF
4535 <
4536 <          cat >>confdefs.h <<\_ACEOF
4537 < #define F90_FUNC_(name,NAME) NAME ## _
4538 < _ACEOF
4539 < ;;
4540 <  "upper case, underscore, no extra underscore")
4541 <          cat >>confdefs.h <<\_ACEOF
4542 < #define F90_FUNC(name,NAME) NAME ## _
4543 < _ACEOF
4544 <
4545 <          cat >>confdefs.h <<\_ACEOF
4546 < #define F90_FUNC_(name,NAME) NAME ## _
4547 < _ACEOF
4548 < ;;
4549 <  "upper case, underscore, extra underscore")
4550 <          cat >>confdefs.h <<\_ACEOF
4551 < #define F90_FUNC(name,NAME) NAME ## _
4552 < _ACEOF
4553 <
4554 <          cat >>confdefs.h <<\_ACEOF
4555 < #define F90_FUNC_(name,NAME) NAME ## __
4556 < _ACEOF
4557 < ;;
4558 <  *)
4559 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4560 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
4561 <          ;;
4562 < esac
4563 <
4564 <
4565 <
4566 <
4567 <
4568 < echo "$as_me:$LINENO: checking for module suffix" >&5
4569 < echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
4570 < rm -f conftest*
4571 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4572 < rm -f work*
4573 < cat >conftest.f90 <<EOF
4574 <        module conftest
4575 <        integer n
4576 <        parameter (n=1)
4577 <        end module conftest
4578 < EOF
4579 < # SGI and absoft compilers generates module name in upper case!
4580 < testname="conftest"
4581 < modcase="lower"
4582 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4583 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
4584 <    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
4585 <    if test -z "$MOD" ; then
4586 <        MOD=`ls CONFTEST* 2>/dev/null \
4587 <                | grep -v CONFTEST.f | grep -v CONFTEST.o`
4588 <        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
4589 <        if test -n "$MOD" ; then
4590 <            testname="CONFTEST"
4591 <            modcase="upper"
4592 <        fi
4593 <    fi
4594 <    if test -z "$MOD" ; then
4595 <        echo "$as_me:$LINENO: result: unknown" >&5
4596 < echo "${ECHO_T}unknown" >&6
4597 <        # Use mod if we can't figure it out
4598 <        MOD="mod"
4599 <    else
4600 <        echo "$as_me:$LINENO: result: $MOD" >&5
4601 < echo "${ECHO_T}$MOD" >&6
4602 <    fi
4603 <    if test -s work.pcl ; then
4604 <        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
4605 < echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
4606 <    fi
4607 < else
4608 <    echo "$as_me:$LINENO: result: unknown" >&5
4609 < echo "${ECHO_T}unknown" >&6
4610 < fi
4611 <
4612 <
4613 <
4614 <
4615 <
4616 < # Check for module include path (some use -I, some (Solaris) use -M, some
4617 < # (absoft) use -p).
4618 < # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
4619 < # specified, work.pcl and work.pc are created.  However, if you specify
4620 < # a file, it must contain a the name of a file ending in .pc .  Ugh!
4621 < # Use the module made above
4622 < echo "$as_me:$LINENO: checking for module directory path flag" >&5
4623 < echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
4624 < rm -f conftest*
4625 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4626 < rm -f work*
4627 < cat >conftest.f90 <<EOF
4628 <        module conftest
4629 <        integer n
4630 <        parameter (n=1)
4631 <        end module conftest
4632 < EOF
4633 < # SGI and absoft compilers generates module name in upper case!
4634 < testname="conftest"
4635 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
4636 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
4637 <   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
4638 <   if test -n "$mod" ; then
4639 <      testname="CONFTEST"
4640 <   fi
4641 <   madedir=0
4642 <   if test ! -d conf ; then mkdir conf ; madedir=1; fi
4643 <   cp $testname.$MOD conf
4644 <   rm -f conftest* CONFTEST*
4645 <   cat >conftest1.f90 <<EOF
4646 <        program main
4647 <        use conftest
4648 <        print *, n
4649 <        end
4650 < EOF
4651 <   F90_WORK_FILES_ARG=""
4652 <   F90MODINCSPEC=""
4653 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
4654 <       MODDIRFLAG="-I"
4655 <       F90MODINCSPEC="-I<dir>"
4656 <       echo "$as_me:$LINENO: result: -I" >&5
4657 < echo "${ECHO_T}-I" >&6
4658 <   elif $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
4659 <       MODDIRFLAG="-M"
4660 <       F90MODINCSPEC="-M<dir>"
4661 <       echo "$as_me:$LINENO: result: -M" >&5
4662 < echo "${ECHO_T}-M" >&6
4663 <   elif $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
4664 <       MODDIRFLAG="-p"
4665 <       F90MODINCSPEC="-p<dir>"
4666 <       echo "$as_me:$LINENO: result: -p" >&5
4667 < echo "${ECHO_T}-p" >&6
4668 <   elif test -s work.pc ; then
4669 <        cp work.pc conf/mpimod.pc
4670 <        echo "mpimod.pc" > conf/mpimod.pcl
4671 <        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
4672 <        if $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
4673 <            MODDIRFLAG='-cl,mpimod.pcl'
4674 <            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
4675 < echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
4676 <            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
4677 <            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
4678 <
4679 <        else
4680 <            # The version of the Intel compiler that I have refuses to let
4681 <            # you put the "work catalog" list anywhere but the current
4682 <            # directory. For example, you cannot in
4683 <         :
4684 <        fi
4685 <   fi
4686 <   if test -z "MODDIRFLAG" ; then
4687 <       echo "$as_me:$LINENO: result: unknown" >&5
4688 < echo "${ECHO_T}unknown" >&6
4689 <   fi
4690 <
4691 <
4692 <   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
4693 <   if test $madedir = 1 ; then rmdir conf ; fi
4694 < fi
4695 <
4696 <
4697 < echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
4698 < echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
4699 < if test "${ac_cv_f90_module_names+set}" = set; then
4700 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4701 < else
4702 <  ac_ext=f90
4703 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4704 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4705 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4706 <
4707 < # carry out the test in a new directory, so that we don't miss anything
4708 < mkdir conftest
4709 < cd conftest
4710 < cat >conftest.$ac_ext <<_ACEOF
4711 < MODULE Bar
4712 < END MODULE Bar
4713 < _ACEOF
4714 < rm -f conftest.$ac_objext
4715 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4716 <  (eval $ac_compile) 2>conftest.er1
4717 <  ac_status=$?
4718 <  grep -v '^ *+' conftest.er1 >conftest.err
4719 <  rm -f conftest.er1
4720 <  cat conftest.err >&5
4721 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4722 <  (exit $ac_status); } &&
4723 <         { ac_try='test -z "$ac_f90_werror_flag"                         || test ! -s conftest.err'
4724 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4725 <  (eval $ac_try) 2>&5
4726 <  ac_status=$?
4727 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4728 <  (exit $ac_status); }; } &&
4729 <         { ac_try='test -s conftest.$ac_objext'
4730 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4731 <  (eval $ac_try) 2>&5
4732 <  ac_status=$?
4733 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4734 <  (exit $ac_status); }; }; then
4735 <  ac_cv_f90_module_names=
4736 < ac_file_list=*
4737 < for ac_file in $ac_file_list; do
4738 <   case $ac_file in
4739 <      # don't care for original source and object files
4740 <      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
4741 <          :
4742 <          ;;
4743 <      # look for new files derived from the file name
4744 <      *conftest*)
4745 <          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
4746 <            ac_exists=false
4747 <  for ac_i in $ac_cv_f90_module_names; do
4748 <    if test x"$ac_pat" = x"$ac_i"; then
4749 <      ac_exists=true
4750 <      break
4751 <    fi
4752 <  done
4753 <
4754 <  if test x"$ac_exists" = xtrue; then
4755 <  :
4756 < else
4757 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4758 < fi
4759 <
4760 <          ;;
4761 <      # look for new files derived from the module name,
4762 <      # with different case translation schemes
4763 <      *Bar*)
4764 <          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
4765 <            ac_exists=false
4766 <  for ac_i in $ac_cv_f90_module_names; do
4767 <    if test x"$ac_pat" = x"$ac_i"; then
4768 <      ac_exists=true
4769 <      break
4770 <    fi
4771 <  done
4772 <
4773 <  if test x"$ac_exists" = xtrue; then
4774 <  :
4775 < else
4776 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4777 < fi
4778 <
4779 <          ;;
4780 <      *bar*)
4781 <          ac_pat=`echo $ac_file | sed s/bar/%module%/`
4782 <            ac_exists=false
4783 <  for ac_i in $ac_cv_f90_module_names; do
4784 <    if test x"$ac_pat" = x"$ac_i"; then
4785 <      ac_exists=true
4786 <      break
4787 <    fi
4788 <  done
4789 <
4790 <  if test x"$ac_exists" = xtrue; then
4791 <  :
4792 < else
4793 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4794 < fi
4795 <
4796 <          ;;
4797 <      *BAR*)
4798 <          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
4799 <            ac_exists=false
4800 <  for ac_i in $ac_cv_f90_module_names; do
4801 <    if test x"$ac_pat" = x"$ac_i"; then
4802 <      ac_exists=true
4803 <      break
4804 <    fi
4805 <  done
4806 <
4807 <  if test x"$ac_exists" = xtrue; then
4808 <  :
4809 < else
4810 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4811 < fi
4812 <
4813 <          ;;
4814 <       # Other files - we have no idea how they are generated
4815 <       *)
4816 <          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
4817 < echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
4818 <          ;;
4819 <   esac
4820 < done
4821 < if test "x$ac_cv_f90_module_names" = "x"; then
4822 <  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4823 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4824 < fi
4825 <
4826 < else
4827 <  echo "$as_me: failed program was:" >&5
4828 < sed 's/^/| /' conftest.$ac_ext >&5
4829 <
4830 < ac_cv_f90_module_names=
4831 < { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
4832 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
4833 < fi
4834 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4835 < cd ..
4836 < # cleanup
4837 < rm -rf conftest
4838 < ac_ext=f90
4839 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4840 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4841 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4842 <
4843 < fi
4844 < echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
4845 < echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
4846 <
4847 < # We now generate a shell script that will help us to figure out the correct
4848 < # module file names, using the value of ac_cv_f90_module_names
4849 <
4850 < echo "Generating shell script modnam"
4851 <
4852 < cat > scripts/modnam << EOF
4853 < #! /bin/sh
4854 < # This script is auto-generated by configure
4855 < #
4856 < usage="\\
4857 < Usage: \$0 [FILES]
4858 <
4859 < [FILES] are Fortran 90 source files.
4860 < The output is a list of module file names that the Fortran 90 compiler
4861 < generates when compiling [FILES]."
4862 <
4863 < list=
4864 < empty=
4865 <
4866 < if test \$# -eq 0; then
4867 <   echo "\$usage"; exit 0
4868 < fi
4869 <
4870 < while test \$# != 0; do
4871 <
4872 <  file=\$1
4873 <  shift
4874 <
4875 < # strip suffix
4876 <  base=\`echo \$file | sed 's/[.][^.]*$//'\`
4877 <
4878 <  test ! -f \$file && continue
4879 <
4880 < # Look for module definitions and transform them to upper / lower case
4881 <  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/'\`
4882 <  upper=\`echo \$mods | tr a-z A-Z\`
4883 <  lower=\`echo \$mods | tr A-Z a-z\`
4884 <
4885 < # Here, the patterns for generating module file names were inserted by configure
4886 <  for trans in $ac_cv_f90_module_names; do
4887 <
4888 <    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
4889 <    var=empty
4890 <    case \$pat in
4891 <       %MODULE%)
4892 <          var=upper ;;
4893 <       %Module%)
4894 <          var=mods ;;
4895 <       %module%)
4896 <          var=lower ;;
4897 <       %FILE%)
4898 <          test -n "\$mods" && var=base ;;
4899 <    esac
4900 <    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
4901 <    list="\$list \$new"
4902 <  done
4903 < done
4904 <
4905 < echo \$list
4906 < # end of configure-generated script
4907 < EOF
4908 < chmod 755 scripts/modnam
4909 <
4910 < pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
4911 < F90_MODULE_NAMES=empty
4912 < case $pat in
4913 <       %MODULE%)
4914 <          F90_MODULE_NAMES=UPPER ;;
4915 <       %Module%)
4916 <          F90_MODULE_NAMES=Mixed ;;
4917 <       %module%)
4918 <          F90_MODULE_NAMES=lower ;;
4919 <       *)
4920 <          F90_MODULE_NAMES=unknown ;;
4921 < esac
4922 <
4923 < ac_ext=c
4924 < ac_cpp='$CPP $CPPFLAGS'
4925 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4926 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4927 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4928 <
4929 <
4930 < ac_ext=cc
4931 < ac_cpp='$CXXCPP $CPPFLAGS'
4932 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4933 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4934 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
4935 <
4936 <
4937 <
4938 < echo "$as_me:$LINENO: checking for asin in -lm" >&5
4939 < echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
4940 < if test "${ac_cv_lib_m_asin+set}" = set; then
4941 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4942 < else
4943 <  ac_check_lib_save_LIBS=$LIBS
4944 < LIBS="-lm  $LIBS"
4945 < cat >conftest.$ac_ext <<_ACEOF
4946 < /* confdefs.h.  */
4947 < _ACEOF
4948 < cat confdefs.h >>conftest.$ac_ext
4949 < cat >>conftest.$ac_ext <<_ACEOF
4950 < /* end confdefs.h.  */
4951 <
4952 < /* Override any gcc2 internal prototype to avoid an error.  */
4953 < #ifdef __cplusplus
4954 < extern "C"
4955 < #endif
4956 < /* We use char because int might match the return type of a gcc2
4957 <   builtin and then its argument prototype would still apply.  */
4958 < char asin ();
4959 < int
4960 < main ()
4961 < {
4962 < asin ();
4963 <  ;
4964 <  return 0;
4965 < }
4966 < _ACEOF
4967 < rm -f conftest.$ac_objext conftest$ac_exeext
4968 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4969 <  (eval $ac_link) 2>conftest.er1
4462 > cat >>confdefs.h <<\_ACEOF
4463 > #define FC_DUMMY_MAIN_EQ_F77 1
4464 > _ACEOF
4465 >
4466 >  fi
4467 > fi
4468 > else
4469 >  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
4470 > See \`config.log' for more details." >&5
4471 > echo "$as_me: error: linking to Fortran libraries from C fails
4472 > See \`config.log' for more details." >&2;}
4473 >   { (exit 1); exit 1; }; }
4474 > fi
4475 >
4476 >
4477 > ac_ext=${FC_SRCEXT-f}
4478 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4479 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4480 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4481 >
4482 > ac_ext=${FC_SRCEXT-f}
4483 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4484 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4485 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4486 > echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
4487 > echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6
4488 > if test "${ac_cv_fc_mangling+set}" = set; then
4489 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4490 > else
4491 >  cat >conftest.$ac_ext <<_ACEOF
4492 >      subroutine foobar()
4493 >      return
4494 >      end
4495 >      subroutine foo_bar()
4496 >      return
4497 >      end
4498 > _ACEOF
4499 > rm -f conftest.$ac_objext
4500 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4501 >  (eval $ac_compile) 2>conftest.er1
4502 >  ac_status=$?
4503 >  grep -v '^ *+' conftest.er1 >conftest.err
4504 >  rm -f conftest.er1
4505 >  cat conftest.err >&5
4506 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4507 >  (exit $ac_status); } &&
4508 >         { ac_try='test -z "$ac_fc_werror_flag"
4509 >                         || test ! -s conftest.err'
4510 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4511 >  (eval $ac_try) 2>&5
4512 >  ac_status=$?
4513 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4514 >  (exit $ac_status); }; } &&
4515 >         { ac_try='test -s conftest.$ac_objext'
4516 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4517 >  (eval $ac_try) 2>&5
4518 >  ac_status=$?
4519 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4520 >  (exit $ac_status); }; }; then
4521 >  mv conftest.$ac_objext cfortran_test.$ac_objext
4522 >
4523 >  ac_save_LIBS=$LIBS
4524 >  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
4525 >
4526 >  ac_ext=c
4527 > ac_cpp='$CPP $CPPFLAGS'
4528 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4529 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4530 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4531 >  ac_success=no
4532 >  for ac_foobar in foobar FOOBAR; do
4533 >    for ac_underscore in "" "_"; do
4534 >      ac_func="$ac_foobar$ac_underscore"
4535 >      cat >conftest.$ac_ext <<_ACEOF
4536 > /* confdefs.h.  */
4537 > _ACEOF
4538 > cat confdefs.h >>conftest.$ac_ext
4539 > cat >>conftest.$ac_ext <<_ACEOF
4540 > /* end confdefs.h.  */
4541 >
4542 > /* Override any gcc2 internal prototype to avoid an error.  */
4543 > #ifdef __cplusplus
4544 > extern "C"
4545 > #endif
4546 > /* We use char because int might match the return type of a gcc2
4547 >   builtin and then its argument prototype would still apply.  */
4548 > char $ac_func ();
4549 > #ifdef FC_DUMMY_MAIN
4550 > #ifndef FC_DUMMY_MAIN_EQ_F77
4551 > #  ifdef __cplusplus
4552 >     extern "C"
4553 > #  endif
4554 >   int FC_DUMMY_MAIN() { return 1; }
4555 > #endif
4556 > #endif
4557 > int
4558 > main ()
4559 > {
4560 > $ac_func ();
4561 >  ;
4562 >  return 0;
4563 > }
4564 > _ACEOF
4565 > rm -f conftest.$ac_objext conftest$ac_exeext
4566 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4567 >  (eval $ac_link) 2>conftest.er1
4568 >  ac_status=$?
4569 >  grep -v '^ *+' conftest.er1 >conftest.err
4570 >  rm -f conftest.er1
4571 >  cat conftest.err >&5
4572 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4573 >  (exit $ac_status); } &&
4574 >         { ac_try='test -z "$ac_c_werror_flag"
4575 >                         || test ! -s conftest.err'
4576 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4577 >  (eval $ac_try) 2>&5
4578 >  ac_status=$?
4579 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4580 >  (exit $ac_status); }; } &&
4581 >         { ac_try='test -s conftest$ac_exeext'
4582 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4583 >  (eval $ac_try) 2>&5
4584 >  ac_status=$?
4585 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4586 >  (exit $ac_status); }; }; then
4587 >  ac_success=yes; break 2
4588 > else
4589 >  echo "$as_me: failed program was:" >&5
4590 > sed 's/^/| /' conftest.$ac_ext >&5
4591 >
4592 > fi
4593 > rm -f conftest.err conftest.$ac_objext \
4594 >      conftest$ac_exeext conftest.$ac_ext
4595 >    done
4596 >  done
4597 >  ac_ext=${FC_SRCEXT-f}
4598 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4599 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4600 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4601 >
4602 >  if test "$ac_success" = "yes"; then
4603 >     case $ac_foobar in
4604 >        foobar)
4605 >           ac_case=lower
4606 >           ac_foo_bar=foo_bar
4607 >           ;;
4608 >        FOOBAR)
4609 >           ac_case=upper
4610 >           ac_foo_bar=FOO_BAR
4611 >           ;;
4612 >     esac
4613 >
4614 >     ac_ext=c
4615 > ac_cpp='$CPP $CPPFLAGS'
4616 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4617 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4618 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4619 >     ac_success_extra=no
4620 >     for ac_extra in "" "_"; do
4621 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
4622 >        cat >conftest.$ac_ext <<_ACEOF
4623 > /* confdefs.h.  */
4624 > _ACEOF
4625 > cat confdefs.h >>conftest.$ac_ext
4626 > cat >>conftest.$ac_ext <<_ACEOF
4627 > /* end confdefs.h.  */
4628 >
4629 > /* Override any gcc2 internal prototype to avoid an error.  */
4630 > #ifdef __cplusplus
4631 > extern "C"
4632 > #endif
4633 > /* We use char because int might match the return type of a gcc2
4634 >   builtin and then its argument prototype would still apply.  */
4635 > char $ac_func ();
4636 > #ifdef FC_DUMMY_MAIN
4637 > #ifndef FC_DUMMY_MAIN_EQ_F77
4638 > #  ifdef __cplusplus
4639 >     extern "C"
4640 > #  endif
4641 >   int FC_DUMMY_MAIN() { return 1; }
4642 > #endif
4643 > #endif
4644 > int
4645 > main ()
4646 > {
4647 > $ac_func ();
4648 >  ;
4649 >  return 0;
4650 > }
4651 > _ACEOF
4652 > rm -f conftest.$ac_objext conftest$ac_exeext
4653 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4654 >  (eval $ac_link) 2>conftest.er1
4655 >  ac_status=$?
4656 >  grep -v '^ *+' conftest.er1 >conftest.err
4657 >  rm -f conftest.er1
4658 >  cat conftest.err >&5
4659 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4660 >  (exit $ac_status); } &&
4661 >         { ac_try='test -z "$ac_c_werror_flag"
4662 >                         || test ! -s conftest.err'
4663 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4664 >  (eval $ac_try) 2>&5
4665 >  ac_status=$?
4666 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4667 >  (exit $ac_status); }; } &&
4668 >         { ac_try='test -s conftest$ac_exeext'
4669 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4670 >  (eval $ac_try) 2>&5
4671 >  ac_status=$?
4672 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4673 >  (exit $ac_status); }; }; then
4674 >  ac_success_extra=yes; break
4675 > else
4676 >  echo "$as_me: failed program was:" >&5
4677 > sed 's/^/| /' conftest.$ac_ext >&5
4678 >
4679 > fi
4680 > rm -f conftest.err conftest.$ac_objext \
4681 >      conftest$ac_exeext conftest.$ac_ext
4682 >     done
4683 >     ac_ext=${FC_SRCEXT-f}
4684 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4685 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4686 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4687 >
4688 >     if test "$ac_success_extra" = "yes"; then
4689 >        ac_cv_fc_mangling="$ac_case case"
4690 >        if test -z "$ac_underscore"; then
4691 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4692 >        else
4693 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4694 >        fi
4695 >        if test -z "$ac_extra"; then
4696 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4697 >        else
4698 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4699 >        fi
4700 >      else
4701 >        ac_cv_fc_mangling="unknown"
4702 >      fi
4703 >  else
4704 >     ac_cv_fc_mangling="unknown"
4705 >  fi
4706 >
4707 >  LIBS=$ac_save_LIBS
4708 >  rm -f cfortran_test* conftest*
4709 > else
4710 >  echo "$as_me: failed program was:" >&5
4711 > sed 's/^/| /' conftest.$ac_ext >&5
4712 >
4713 > { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
4714 > See \`config.log' for more details." >&5
4715 > echo "$as_me: error: cannot compile a simple Fortran program
4716 > See \`config.log' for more details." >&2;}
4717 >   { (exit 1); exit 1; }; }
4718 > fi
4719 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4720 >
4721 > fi
4722 > echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
4723 > echo "${ECHO_T}$ac_cv_fc_mangling" >&6
4724 >
4725 > ac_ext=${FC_SRCEXT-f}
4726 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4727 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4728 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4729 >
4730 > ac_ext=${FC_SRCEXT-f}
4731 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4732 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4733 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4734 >
4735 >
4736 > case $ac_cv_fc_mangling in
4737 >  "lower case, no underscore, no extra underscore")
4738 >          cat >>confdefs.h <<\_ACEOF
4739 > #define FC_FUNC(name,NAME) name
4740 > _ACEOF
4741 >
4742 >          cat >>confdefs.h <<\_ACEOF
4743 > #define FC_FUNC_(name,NAME) name
4744 > _ACEOF
4745 > ;;
4746 >  "lower case, no underscore, extra underscore")
4747 >          cat >>confdefs.h <<\_ACEOF
4748 > #define FC_FUNC(name,NAME) name
4749 > _ACEOF
4750 >
4751 >          cat >>confdefs.h <<\_ACEOF
4752 > #define FC_FUNC_(name,NAME) name ## _
4753 > _ACEOF
4754 > ;;
4755 >  "lower case, underscore, no extra underscore")
4756 >          cat >>confdefs.h <<\_ACEOF
4757 > #define FC_FUNC(name,NAME) name ## _
4758 > _ACEOF
4759 >
4760 >          cat >>confdefs.h <<\_ACEOF
4761 > #define FC_FUNC_(name,NAME) name ## _
4762 > _ACEOF
4763 > ;;
4764 >  "lower case, underscore, extra underscore")
4765 >          cat >>confdefs.h <<\_ACEOF
4766 > #define FC_FUNC(name,NAME) name ## _
4767 > _ACEOF
4768 >
4769 >          cat >>confdefs.h <<\_ACEOF
4770 > #define FC_FUNC_(name,NAME) name ## __
4771 > _ACEOF
4772 > ;;
4773 >  "upper case, no underscore, no extra underscore")
4774 >          cat >>confdefs.h <<\_ACEOF
4775 > #define FC_FUNC(name,NAME) NAME
4776 > _ACEOF
4777 >
4778 >          cat >>confdefs.h <<\_ACEOF
4779 > #define FC_FUNC_(name,NAME) NAME
4780 > _ACEOF
4781 > ;;
4782 >  "upper case, no underscore, extra underscore")
4783 >          cat >>confdefs.h <<\_ACEOF
4784 > #define FC_FUNC(name,NAME) NAME
4785 > _ACEOF
4786 >
4787 >          cat >>confdefs.h <<\_ACEOF
4788 > #define FC_FUNC_(name,NAME) NAME ## _
4789 > _ACEOF
4790 > ;;
4791 >  "upper case, underscore, no extra underscore")
4792 >          cat >>confdefs.h <<\_ACEOF
4793 > #define FC_FUNC(name,NAME) NAME ## _
4794 > _ACEOF
4795 >
4796 >          cat >>confdefs.h <<\_ACEOF
4797 > #define FC_FUNC_(name,NAME) NAME ## _
4798 > _ACEOF
4799 > ;;
4800 >  "upper case, underscore, extra underscore")
4801 >          cat >>confdefs.h <<\_ACEOF
4802 > #define FC_FUNC(name,NAME) NAME ## _
4803 > _ACEOF
4804 >
4805 >          cat >>confdefs.h <<\_ACEOF
4806 > #define FC_FUNC_(name,NAME) NAME ## __
4807 > _ACEOF
4808 > ;;
4809 >  *)
4810 >          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
4811 > echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
4812 >          ;;
4813 > esac
4814 >
4815 > ac_ext=${FC_SRCEXT-f}
4816 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4817 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4818 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4819 >
4820 >
4821 >
4822 > ac_ext=${FC_SRCEXT-f}
4823 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
4824 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
4825 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4826 > echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
4827 > echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6
4828 > if test "${ac_cv_prog_fc_v+set}" = set; then
4829 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4830 > else
4831 >  cat >conftest.$ac_ext <<_ACEOF
4832 >      program main
4833 >
4834 >      end
4835 > _ACEOF
4836 > rm -f conftest.$ac_objext
4837 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4838 >  (eval $ac_compile) 2>conftest.er1
4839 >  ac_status=$?
4840 >  grep -v '^ *+' conftest.er1 >conftest.err
4841 >  rm -f conftest.er1
4842 >  cat conftest.err >&5
4843 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4844 >  (exit $ac_status); } &&
4845 >         { ac_try='test -z "$ac_fc_werror_flag"
4846 >                         || test ! -s conftest.err'
4847 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4848 >  (eval $ac_try) 2>&5
4849 >  ac_status=$?
4850 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4851 >  (exit $ac_status); }; } &&
4852 >         { ac_try='test -s conftest.$ac_objext'
4853 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4854 >  (eval $ac_try) 2>&5
4855 >  ac_status=$?
4856 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4857 >  (exit $ac_status); }; }; then
4858 >  ac_cv_prog_fc_v=
4859 > # Try some options frequently used verbose output
4860 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
4861 >  cat >conftest.$ac_ext <<_ACEOF
4862 >      program main
4863 >
4864 >      end
4865 > _ACEOF
4866 >
4867 > # Compile and link our simple test program by passing a flag (argument
4868 > # 1 to this macro) to the Fortran compiler in order to get
4869 > # "verbose" output that we can then parse for the Fortran linker
4870 > # flags.
4871 > ac_save_FFLAGS=$FCFLAGS
4872 > FCFLAGS="$FCFLAGS $ac_verb"
4873 > (eval echo $as_me:4873: \"$ac_link\") >&5
4874 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4875 > echo "$ac_fc_v_output" >&5
4876 > FCFLAGS=$ac_save_FFLAGS
4877 >
4878 > rm -f conftest*
4879 >
4880 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4881 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4882 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4883 > ac_fc_v_output="`echo $ac_fc_v_output |
4884 >        grep 'LPATH is:' |
4885 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4886 >
4887 > case $ac_fc_v_output in
4888 >  # If we are using xlf then replace all the commas with spaces.
4889 >  *xlfentry*)
4890 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4891 >
4892 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4893 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4894 >  *mGLOB_options_string*)
4895 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4896 >
4897 >  # If we are using Cray Fortran then delete quotes.
4898 >  # Use "\"" instead of '"' for font-lock-mode.
4899 >  # FIXME: a more general fix for quoted arguments with spaces?
4900 >  *cft90*)
4901 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4902 > esac
4903 >
4904 >
4905 >  # look for -l* and *.a constructs in the output
4906 >  for ac_arg in $ac_fc_v_output; do
4907 >     case $ac_arg in
4908 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4909 >          ac_cv_prog_fc_v=$ac_verb
4910 >          break 2 ;;
4911 >     esac
4912 >  done
4913 > done
4914 > if test -z "$ac_cv_prog_fc_v"; then
4915 >   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
4916 > echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
4917 > fi
4918 > else
4919 >  echo "$as_me: failed program was:" >&5
4920 > sed 's/^/| /' conftest.$ac_ext >&5
4921 >
4922 > { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
4923 > echo "$as_me: WARNING: compilation failed" >&2;}
4924 > fi
4925 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4926 >
4927 > fi
4928 > echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
4929 > echo "${ECHO_T}$ac_cv_prog_fc_v" >&6
4930 > echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
4931 > echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6
4932 > if test "${ac_cv_fc_libs+set}" = set; then
4933 >  echo $ECHO_N "(cached) $ECHO_C" >&6
4934 > else
4935 >  if test "x$FCLIBS" != "x"; then
4936 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4937 > else
4938 >
4939 > cat >conftest.$ac_ext <<_ACEOF
4940 >      program main
4941 >
4942 >      end
4943 > _ACEOF
4944 >
4945 > # Compile and link our simple test program by passing a flag (argument
4946 > # 1 to this macro) to the Fortran compiler in order to get
4947 > # "verbose" output that we can then parse for the Fortran linker
4948 > # flags.
4949 > ac_save_FFLAGS=$FCFLAGS
4950 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
4951 > (eval echo $as_me:4951: \"$ac_link\") >&5
4952 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
4953 > echo "$ac_fc_v_output" >&5
4954 > FCFLAGS=$ac_save_FFLAGS
4955 >
4956 > rm -f conftest*
4957 >
4958 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
4959 > # /foo, /bar, and /baz are search directories for the Fortran linker.
4960 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
4961 > ac_fc_v_output="`echo $ac_fc_v_output |
4962 >        grep 'LPATH is:' |
4963 >        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
4964 >
4965 > case $ac_fc_v_output in
4966 >  # If we are using xlf then replace all the commas with spaces.
4967 >  *xlfentry*)
4968 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
4969 >
4970 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
4971 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
4972 >  *mGLOB_options_string*)
4973 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/\"-mGLOB[^\"]*\"/ /g'` ;;
4974 >
4975 >  # If we are using Cray Fortran then delete quotes.
4976 >  # Use "\"" instead of '"' for font-lock-mode.
4977 >  # FIXME: a more general fix for quoted arguments with spaces?
4978 >  *cft90*)
4979 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "s/\"//g"` ;;
4980 > esac
4981 >
4982 >
4983 >
4984 > ac_cv_fc_libs=
4985 >
4986 > # Save positional arguments (if any)
4987 > ac_save_positional="$@"
4988 >
4989 > set X $ac_fc_v_output
4990 > while test $# != 1; do
4991 >  shift
4992 >  ac_arg=$1
4993 >  case $ac_arg in
4994 >        [\\/]*.a | ?:[\\/]*.a)
4995 >            ac_exists=false
4996 >  for ac_i in $ac_cv_fc_libs; do
4997 >    if test x"$ac_arg" = x"$ac_i"; then
4998 >      ac_exists=true
4999 >      break
5000 >    fi
5001 >  done
5002 >
5003 >  if test x"$ac_exists" = xtrue; then
5004 >  :
5005 > else
5006 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5007 > fi
5008 >
5009 >          ;;
5010 >        -bI:*)
5011 >            ac_exists=false
5012 >  for ac_i in $ac_cv_fc_libs; do
5013 >    if test x"$ac_arg" = x"$ac_i"; then
5014 >      ac_exists=true
5015 >      break
5016 >    fi
5017 >  done
5018 >
5019 >  if test x"$ac_exists" = xtrue; then
5020 >  :
5021 > else
5022 >  if test "$ac_compiler_gnu" = yes; then
5023 >  for ac_link_opt in $ac_arg; do
5024 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5025 >  done
5026 > else
5027 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5028 > fi
5029 > fi
5030 >
5031 >          ;;
5032 >          # Ignore these flags.
5033 >        -lang* | -lcrt[01].o | -lcrtbegin.o | -lc | -lgcc | -libmil | -LANG:=*)
5034 >          ;;
5035 >        -lkernel32)
5036 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5037 >          ;;
5038 >        -[LRuY])
5039 >          # These flags, when seen by themselves, take an argument.
5040 >          # We remove the space between option and argument and re-iterate
5041 >          # unless we find an empty arg or a new option (starting with -)
5042 >          case $2 in
5043 >             "" | -*);;
5044 >             *)
5045 >                ac_arg="$ac_arg$2"
5046 >                shift; shift
5047 >                set X $ac_arg "$@"
5048 >                ;;
5049 >          esac
5050 >          ;;
5051 >        -YP,*)
5052 >          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
5053 >              ac_exists=false
5054 >  for ac_i in $ac_cv_fc_libs; do
5055 >    if test x"$ac_j" = x"$ac_i"; then
5056 >      ac_exists=true
5057 >      break
5058 >    fi
5059 >  done
5060 >
5061 >  if test x"$ac_exists" = xtrue; then
5062 >  :
5063 > else
5064 >  ac_arg="$ac_arg $ac_j"
5065 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
5066 > fi
5067 >
5068 >          done
5069 >          ;;
5070 >        -[lLR]*)
5071 >            ac_exists=false
5072 >  for ac_i in $ac_cv_fc_libs; do
5073 >    if test x"$ac_arg" = x"$ac_i"; then
5074 >      ac_exists=true
5075 >      break
5076 >    fi
5077 >  done
5078 >
5079 >  if test x"$ac_exists" = xtrue; then
5080 >  :
5081 > else
5082 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
5083 > fi
5084 >
5085 >          ;;
5086 >          # Ignore everything else.
5087 >  esac
5088 > done
5089 > # restore positional arguments
5090 > set X $ac_save_positional; shift
5091 >
5092 > # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
5093 > # then we insist that the "run path" must be an absolute path (i.e. it
5094 > # must begin with a "/").
5095 > case `(uname -sr) 2>/dev/null` in
5096 >   "SunOS 5"*)
5097 >      ac_ld_run_path=`echo $ac_fc_v_output |
5098 >                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
5099 >      test "x$ac_ld_run_path" != x &&
5100 >        if test "$ac_compiler_gnu" = yes; then
5101 >  for ac_link_opt in $ac_ld_run_path; do
5102 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
5103 >  done
5104 > else
5105 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
5106 > fi
5107 >      ;;
5108 > esac
5109 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
5110 >
5111 > fi
5112 > echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
5113 > echo "${ECHO_T}$ac_cv_fc_libs" >&6
5114 > FCLIBS="$ac_cv_fc_libs"
5115 >
5116 >
5117 > ac_ext=${FC_SRCEXT-f}
5118 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5119 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5120 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5121 >
5122 >
5123 >
5124 > echo "$as_me:$LINENO: checking for module suffix" >&5
5125 > echo $ECHO_N "checking for module suffix... $ECHO_C" >&6
5126 > rm -f conftest*
5127 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5128 > rm -f work*
5129 > cat >conftest.$ac_ext <<EOF
5130 >        module conftest
5131 >        integer n
5132 >        parameter (n=1)
5133 >        end module conftest
5134 > EOF
5135 > # SGI and absoft compilers generates module name in upper case!
5136 > testname="conftest"
5137 > modcase="lower"
5138 > if (eval $ac_compile) 2>/dev/null ; then
5139 >    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
5140 >    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
5141 >    if test -z "$MOD" ; then
5142 >        MOD=`ls CONFTEST* 2>/dev/null \
5143 >                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5144 >        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
5145 >        if test -n "$MOD" ; then
5146 >            testname="CONFTEST"
5147 >            modcase="upper"
5148 >        fi
5149 >    fi
5150 >    if test -z "$MOD" ; then
5151 >        echo "$as_me:$LINENO: result: unknown" >&5
5152 > echo "${ECHO_T}unknown" >&6
5153 >        # Use mod if we can't figure it out
5154 >        MOD="mod"
5155 >    else
5156 >        echo "$as_me:$LINENO: result: $MOD" >&5
5157 > echo "${ECHO_T}$MOD" >&6
5158 >    fi
5159 >    if test -s work.pcl ; then
5160 >        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
5161 > echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
5162 >    fi
5163 > else
5164 >    echo "$as_me:$LINENO: result: unknown" >&5
5165 > echo "${ECHO_T}unknown" >&6
5166 > fi
5167 >
5168 >
5169 >
5170 >
5171 >
5172 > # Check for module include path (some use -I, some (Solaris) use -M, some
5173 > # (absoft) use -p).
5174 > # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
5175 > # specified, work.pcl and work.pc are created.  However, if you specify
5176 > # a file, it must contain a the name of a file ending in .pc .  Ugh!
5177 > # Use the module made above
5178 > echo "$as_me:$LINENO: checking for module directory path flag" >&5
5179 > echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6
5180 > rm -f conftest*
5181 > # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
5182 > rm -f work*
5183 > cat >conftest.$ac_ext <<EOF
5184 >        module conftest
5185 >        integer n
5186 >        parameter (n=1)
5187 >        end module conftest
5188 > EOF
5189 > # SGI and absoft compilers generates module name in upper case!
5190 > testname="conftest"
5191 > if (eval $ac_compile) 2>/dev/null ; then
5192 >   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
5193 >   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
5194 >   if test -n "$mod" ; then
5195 >      testname="CONFTEST"
5196 >   fi
5197 >   madedir=0
5198 >   if test ! -d conf ; then mkdir conf ; madedir=1; fi
5199 >   cp $testname.$MOD conf
5200 >   rm -f conftest* CONFTEST*
5201 >   cat >conftest1.$ac_ext <<EOF
5202 >        program main
5203 >        use conftest
5204 >        print *, n
5205 >        end
5206 > EOF
5207 >   F90_WORK_FILES_ARG=""
5208 >   F90MODINCSPEC=""
5209 >   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
5210 >       MODDIRFLAG="-I"
5211 >       F90MODINCSPEC="-I<dir>"
5212 >       echo "$as_me:$LINENO: result: -I" >&5
5213 > echo "${ECHO_T}-I" >&6
5214 >   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5215 >       MODDIRFLAG="-M"
5216 >       F90MODINCSPEC="-M<dir>"
5217 >       echo "$as_me:$LINENO: result: -M" >&5
5218 > echo "${ECHO_T}-M" >&6
5219 >   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
5220 >       MODDIRFLAG="-p"
5221 >       F90MODINCSPEC="-p<dir>"
5222 >       echo "$as_me:$LINENO: result: -p" >&5
5223 > echo "${ECHO_T}-p" >&6
5224 >   elif test -s work.pc ; then
5225 >        cp work.pc conf/mpimod.pc
5226 >        echo "mpimod.pc" > conf/mpimod.pcl
5227 >        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
5228 >        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
5229 >            MODDIRFLAG='-cl,mpimod.pcl'
5230 >            echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
5231 > echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6
5232 >            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
5233 >            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
5234 >
5235 >        else
5236 >            # The version of the Intel compiler that I have refuses to let
5237 >            # you put the "work catalog" list anywhere but the current
5238 >            # directory. For example, you cannot in
5239 >         :
5240 >        fi
5241 >   fi
5242 >   if test -z "MODDIRFLAG" ; then
5243 >       echo "$as_me:$LINENO: result: unknown" >&5
5244 > echo "${ECHO_T}unknown" >&6
5245 >   fi
5246 >
5247 >
5248 >   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
5249 >   if test $madedir = 1 ; then rmdir conf ; fi
5250 > fi
5251 >
5252 >
5253 > echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
5254 > echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6
5255 > if test "${ac_cv_f90_module_names+set}" = set; then
5256 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5257 > else
5258 >  ac_ext=${FC_SRCEXT-f}
5259 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5260 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5261 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5262 >
5263 > # carry out the test in a new directory, so that we don't miss anything
5264 > mkdir conftest
5265 > cd conftest
5266 > cat >conftest.$ac_ext <<_ACEOF
5267 > MODULE Bar
5268 > END MODULE Bar
5269 > _ACEOF
5270 > rm -f conftest.$ac_objext
5271 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5272 >  (eval $ac_compile) 2>conftest.er1
5273 >  ac_status=$?
5274 >  grep -v '^ *+' conftest.er1 >conftest.err
5275 >  rm -f conftest.er1
5276 >  cat conftest.err >&5
5277 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5278 >  (exit $ac_status); } &&
5279 >         { ac_try='test -z "$ac_fc_werror_flag"
5280 >                         || test ! -s conftest.err'
5281 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5282 >  (eval $ac_try) 2>&5
5283 >  ac_status=$?
5284 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5285 >  (exit $ac_status); }; } &&
5286 >         { ac_try='test -s conftest.$ac_objext'
5287 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5288 >  (eval $ac_try) 2>&5
5289 >  ac_status=$?
5290 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5291 >  (exit $ac_status); }; }; then
5292 >  ac_cv_f90_module_names=
5293 > ac_file_list=*
5294 > for ac_file in $ac_file_list; do
5295 >   case $ac_file in
5296 >      # don't care for original source and object files
5297 >      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
5298 >          :
5299 >          ;;
5300 >      # look for new files derived from the file name
5301 >      *conftest*)
5302 >          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
5303 >            ac_exists=false
5304 >  for ac_i in $ac_cv_f90_module_names; do
5305 >    if test x"$ac_pat" = x"$ac_i"; then
5306 >      ac_exists=true
5307 >      break
5308 >    fi
5309 >  done
5310 >
5311 >  if test x"$ac_exists" = xtrue; then
5312 >  :
5313 > else
5314 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5315 > fi
5316 >
5317 >          ;;
5318 >      # look for new files derived from the module name,
5319 >      # with different case translation schemes
5320 >      *Bar*)
5321 >          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
5322 >            ac_exists=false
5323 >  for ac_i in $ac_cv_f90_module_names; do
5324 >    if test x"$ac_pat" = x"$ac_i"; then
5325 >      ac_exists=true
5326 >      break
5327 >    fi
5328 >  done
5329 >
5330 >  if test x"$ac_exists" = xtrue; then
5331 >  :
5332 > else
5333 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5334 > fi
5335 >
5336 >          ;;
5337 >      *bar*)
5338 >          ac_pat=`echo $ac_file | sed s/bar/%module%/`
5339 >            ac_exists=false
5340 >  for ac_i in $ac_cv_f90_module_names; do
5341 >    if test x"$ac_pat" = x"$ac_i"; then
5342 >      ac_exists=true
5343 >      break
5344 >    fi
5345 >  done
5346 >
5347 >  if test x"$ac_exists" = xtrue; then
5348 >  :
5349 > else
5350 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5351 > fi
5352 >
5353 >          ;;
5354 >      *BAR*)
5355 >          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
5356 >            ac_exists=false
5357 >  for ac_i in $ac_cv_f90_module_names; do
5358 >    if test x"$ac_pat" = x"$ac_i"; then
5359 >      ac_exists=true
5360 >      break
5361 >    fi
5362 >  done
5363 >
5364 >  if test x"$ac_exists" = xtrue; then
5365 >  :
5366 > else
5367 >  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
5368 > fi
5369 >
5370 >          ;;
5371 >       # Other files - we have no idea how they are generated
5372 >       *)
5373 >          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
5374 > echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
5375 >          ;;
5376 >   esac
5377 > done
5378 > if test "x$ac_cv_f90_module_names" = "x"; then
5379 >  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5380 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5381 > fi
5382 >
5383 > else
5384 >  echo "$as_me: failed program was:" >&5
5385 > sed 's/^/| /' conftest.$ac_ext >&5
5386 >
5387 > ac_cv_f90_module_names=
5388 > { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
5389 > echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5390 > fi
5391 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5392 > cd ..
5393 > # cleanup
5394 > rm -rf conftest
5395 > ac_ext=${FC_SRCEXT-f}
5396 > ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
5397 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
5398 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5399 >
5400 > fi
5401 > echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
5402 > echo "${ECHO_T}$ac_cv_f90_module_names" >&6 # AC_CACHE_CHECK
5403 >
5404 > # We now generate a shell script that will help us to figure out the correct
5405 > # module file names, using the value of ac_cv_f90_module_names
5406 >
5407 > echo "Generating shell script modnam"
5408 >
5409 > cat > scripts/modnam << EOF
5410 > #! /bin/sh
5411 > # This script is auto-generated by configure
5412 > #
5413 > usage="\\
5414 > Usage: \$0 [FILES]
5415 >
5416 > [FILES] are Fortran 90 source files.
5417 > The output is a list of module file names that the Fortran 90 compiler
5418 > generates when compiling [FILES]."
5419 >
5420 > list=
5421 > empty=
5422 >
5423 > if test \$# -eq 0; then
5424 >   echo "\$usage"; exit 0
5425 > fi
5426 >
5427 > while test \$# != 0; do
5428 >
5429 >  file=\$1
5430 >  shift
5431 >
5432 > # strip suffix
5433 >  base=\`echo \$file | sed 's/[.][^.]*$//'\`
5434 >
5435 >  test ! -f \$file && continue
5436 >
5437 > # Look for module definitions and transform them to upper / lower case
5438 >  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/'\`
5439 >  upper=\`echo \$mods | tr a-z A-Z\`
5440 >  lower=\`echo \$mods | tr A-Z a-z\`
5441 >
5442 > # Here, the patterns for generating module file names were inserted by configure
5443 >  for trans in $ac_cv_f90_module_names; do
5444 >
5445 >    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
5446 >    var=empty
5447 >    case \$pat in
5448 >       %MODULE%)
5449 >          var=upper ;;
5450 >       %Module%)
5451 >          var=mods ;;
5452 >       %module%)
5453 >          var=lower ;;
5454 >       %FILE%)
5455 >          test -n "\$mods" && var=base ;;
5456 >    esac
5457 >    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
5458 >    list="\$list \$new"
5459 >  done
5460 > done
5461 >
5462 > echo \$list
5463 > # end of configure-generated script
5464 > EOF
5465 > chmod 755 scripts/modnam
5466 >
5467 > pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
5468 > F90_MODULE_NAMES=empty
5469 > case $pat in
5470 >       %MODULE%)
5471 >          F90_MODULE_NAMES=UPPER ;;
5472 >       %Module%)
5473 >          F90_MODULE_NAMES=Mixed ;;
5474 >       %module%)
5475 >          F90_MODULE_NAMES=lower ;;
5476 >       *)
5477 >          F90_MODULE_NAMES=unknown ;;
5478 > esac
5479 >
5480 > ac_ext=c
5481 > ac_cpp='$CPP $CPPFLAGS'
5482 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5483 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5484 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5485 >
5486 >
5487 > ac_ext=c
5488 > ac_cpp='$CPP $CPPFLAGS'
5489 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5490 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5491 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5492 >
5493 >
5494 >
5495 > echo "$as_me:$LINENO: checking for asin in -lm" >&5
5496 > echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
5497 > if test "${ac_cv_lib_m_asin+set}" = set; then
5498 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5499 > else
5500 >  ac_check_lib_save_LIBS=$LIBS
5501 > LIBS="-lm  $LIBS"
5502 > cat >conftest.$ac_ext <<_ACEOF
5503 > /* confdefs.h.  */
5504 > _ACEOF
5505 > cat confdefs.h >>conftest.$ac_ext
5506 > cat >>conftest.$ac_ext <<_ACEOF
5507 > /* end confdefs.h.  */
5508 >
5509 > /* Override any gcc2 internal prototype to avoid an error.  */
5510 > #ifdef __cplusplus
5511 > extern "C"
5512 > #endif
5513 > /* We use char because int might match the return type of a gcc2
5514 >   builtin and then its argument prototype would still apply.  */
5515 > char asin ();
5516 > #ifdef FC_DUMMY_MAIN
5517 > #ifndef FC_DUMMY_MAIN_EQ_F77
5518 > #  ifdef __cplusplus
5519 >     extern "C"
5520 > #  endif
5521 >   int FC_DUMMY_MAIN() { return 1; }
5522 > #endif
5523 > #endif
5524 > int
5525 > main ()
5526 > {
5527 > asin ();
5528 >  ;
5529 >  return 0;
5530 > }
5531 > _ACEOF
5532 > rm -f conftest.$ac_objext conftest$ac_exeext
5533 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5534 >  (eval $ac_link) 2>conftest.er1
5535 >  ac_status=$?
5536 >  grep -v '^ *+' conftest.er1 >conftest.err
5537 >  rm -f conftest.er1
5538 >  cat conftest.err >&5
5539 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5540 >  (exit $ac_status); } &&
5541 >         { ac_try='test -z "$ac_c_werror_flag"
5542 >                         || test ! -s conftest.err'
5543 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5544 >  (eval $ac_try) 2>&5
5545 >  ac_status=$?
5546 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5547 >  (exit $ac_status); }; } &&
5548 >         { ac_try='test -s conftest$ac_exeext'
5549 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5550 >  (eval $ac_try) 2>&5
5551 >  ac_status=$?
5552 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5553 >  (exit $ac_status); }; }; then
5554 >  ac_cv_lib_m_asin=yes
5555 > else
5556 >  echo "$as_me: failed program was:" >&5
5557 > sed 's/^/| /' conftest.$ac_ext >&5
5558 >
5559 > ac_cv_lib_m_asin=no
5560 > fi
5561 > rm -f conftest.err conftest.$ac_objext \
5562 >      conftest$ac_exeext conftest.$ac_ext
5563 > LIBS=$ac_check_lib_save_LIBS
5564 > fi
5565 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5566 > echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
5567 > if test $ac_cv_lib_m_asin = yes; then
5568 >  cat >>confdefs.h <<_ACEOF
5569 > #define HAVE_LIBM 1
5570 > _ACEOF
5571 >
5572 >  LIBS="-lm $LIBS"
5573 >
5574 > else
5575 >  exit
5576 > fi
5577 >
5578 >
5579 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5580 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5581 > if test "${ac_cv_header_stdc+set}" = set; then
5582 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5583 > else
5584 >  cat >conftest.$ac_ext <<_ACEOF
5585 > /* confdefs.h.  */
5586 > _ACEOF
5587 > cat confdefs.h >>conftest.$ac_ext
5588 > cat >>conftest.$ac_ext <<_ACEOF
5589 > /* end confdefs.h.  */
5590 > #include <stdlib.h>
5591 > #include <stdarg.h>
5592 > #include <string.h>
5593 > #include <float.h>
5594 >
5595 > #ifdef FC_DUMMY_MAIN
5596 > #ifndef FC_DUMMY_MAIN_EQ_F77
5597 > #  ifdef __cplusplus
5598 >     extern "C"
5599 > #  endif
5600 >   int FC_DUMMY_MAIN() { return 1; }
5601 > #endif
5602 > #endif
5603 > int
5604 > main ()
5605 > {
5606 >
5607 >  ;
5608 >  return 0;
5609 > }
5610 > _ACEOF
5611 > rm -f conftest.$ac_objext
5612 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5613 >  (eval $ac_compile) 2>conftest.er1
5614 >  ac_status=$?
5615 >  grep -v '^ *+' conftest.er1 >conftest.err
5616 >  rm -f conftest.er1
5617 >  cat conftest.err >&5
5618 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5619 >  (exit $ac_status); } &&
5620 >         { ac_try='test -z "$ac_c_werror_flag"
5621 >                         || test ! -s conftest.err'
5622 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5623 >  (eval $ac_try) 2>&5
5624 >  ac_status=$?
5625 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5626 >  (exit $ac_status); }; } &&
5627 >         { ac_try='test -s conftest.$ac_objext'
5628 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5629 >  (eval $ac_try) 2>&5
5630 >  ac_status=$?
5631 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5632 >  (exit $ac_status); }; }; then
5633 >  ac_cv_header_stdc=yes
5634 > else
5635 >  echo "$as_me: failed program was:" >&5
5636 > sed 's/^/| /' conftest.$ac_ext >&5
5637 >
5638 > ac_cv_header_stdc=no
5639 > fi
5640 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5641 >
5642 > if test $ac_cv_header_stdc = yes; then
5643 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5644 >  cat >conftest.$ac_ext <<_ACEOF
5645 > /* confdefs.h.  */
5646 > _ACEOF
5647 > cat confdefs.h >>conftest.$ac_ext
5648 > cat >>conftest.$ac_ext <<_ACEOF
5649 > /* end confdefs.h.  */
5650 > #include <string.h>
5651 >
5652 > _ACEOF
5653 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5654 >  $EGREP "memchr" >/dev/null 2>&1; then
5655 >  :
5656 > else
5657 >  ac_cv_header_stdc=no
5658 > fi
5659 > rm -f conftest*
5660 >
5661 > fi
5662 >
5663 > if test $ac_cv_header_stdc = yes; then
5664 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5665 >  cat >conftest.$ac_ext <<_ACEOF
5666 > /* confdefs.h.  */
5667 > _ACEOF
5668 > cat confdefs.h >>conftest.$ac_ext
5669 > cat >>conftest.$ac_ext <<_ACEOF
5670 > /* end confdefs.h.  */
5671 > #include <stdlib.h>
5672 >
5673 > _ACEOF
5674 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5675 >  $EGREP "free" >/dev/null 2>&1; then
5676 >  :
5677 > else
5678 >  ac_cv_header_stdc=no
5679 > fi
5680 > rm -f conftest*
5681 >
5682 > fi
5683 >
5684 > if test $ac_cv_header_stdc = yes; then
5685 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5686 >  if test "$cross_compiling" = yes; then
5687 >  :
5688 > else
5689 >  cat >conftest.$ac_ext <<_ACEOF
5690 > /* confdefs.h.  */
5691 > _ACEOF
5692 > cat confdefs.h >>conftest.$ac_ext
5693 > cat >>conftest.$ac_ext <<_ACEOF
5694 > /* end confdefs.h.  */
5695 > #include <ctype.h>
5696 > #if ((' ' & 0x0FF) == 0x020)
5697 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5698 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5699 > #else
5700 > # define ISLOWER(c) \
5701 >                   (('a' <= (c) && (c) <= 'i') \
5702 >                     || ('j' <= (c) && (c) <= 'r') \
5703 >                     || ('s' <= (c) && (c) <= 'z'))
5704 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5705 > #endif
5706 >
5707 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5708 > int
5709 > main ()
5710 > {
5711 >  int i;
5712 >  for (i = 0; i < 256; i++)
5713 >    if (XOR (islower (i), ISLOWER (i))
5714 >        || toupper (i) != TOUPPER (i))
5715 >      exit(2);
5716 >  exit (0);
5717 > }
5718 > _ACEOF
5719 > rm -f conftest$ac_exeext
5720 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5721 >  (eval $ac_link) 2>&5
5722 >  ac_status=$?
5723 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5724 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
5725 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5726 >  (eval $ac_try) 2>&5
5727 >  ac_status=$?
5728 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5729 >  (exit $ac_status); }; }; then
5730 >  :
5731 > else
5732 >  echo "$as_me: program exited with status $ac_status" >&5
5733 > echo "$as_me: failed program was:" >&5
5734 > sed 's/^/| /' conftest.$ac_ext >&5
5735 >
5736 > ( exit $ac_status )
5737 > ac_cv_header_stdc=no
5738 > fi
5739 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5740 > fi
5741 > fi
5742 > fi
5743 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5744 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
5745 > if test $ac_cv_header_stdc = yes; then
5746 >
5747 > cat >>confdefs.h <<\_ACEOF
5748 > #define STDC_HEADERS 1
5749 > _ACEOF
5750 >
5751 > fi
5752 >
5753 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5754 >
5755 >
5756 >
5757 >
5758 >
5759 >
5760 >
5761 >
5762 >
5763 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5764 >                  inttypes.h stdint.h unistd.h
5765 > do
5766 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5767 > echo "$as_me:$LINENO: checking for $ac_header" >&5
5768 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5769 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
5770 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5771 > else
5772 >  cat >conftest.$ac_ext <<_ACEOF
5773 > /* confdefs.h.  */
5774 > _ACEOF
5775 > cat confdefs.h >>conftest.$ac_ext
5776 > cat >>conftest.$ac_ext <<_ACEOF
5777 > /* end confdefs.h.  */
5778 > $ac_includes_default
5779 >
5780 > #include <$ac_header>
5781 > _ACEOF
5782 > rm -f conftest.$ac_objext
5783 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5784 >  (eval $ac_compile) 2>conftest.er1
5785 >  ac_status=$?
5786 >  grep -v '^ *+' conftest.er1 >conftest.err
5787 >  rm -f conftest.er1
5788 >  cat conftest.err >&5
5789 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5790 >  (exit $ac_status); } &&
5791 >         { ac_try='test -z "$ac_c_werror_flag"
5792 >                         || test ! -s conftest.err'
5793 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5794 >  (eval $ac_try) 2>&5
5795 >  ac_status=$?
5796 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5797 >  (exit $ac_status); }; } &&
5798 >         { ac_try='test -s conftest.$ac_objext'
5799 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5800 >  (eval $ac_try) 2>&5
5801 >  ac_status=$?
5802 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5803 >  (exit $ac_status); }; }; then
5804 >  eval "$as_ac_Header=yes"
5805 > else
5806 >  echo "$as_me: failed program was:" >&5
5807 > sed 's/^/| /' conftest.$ac_ext >&5
5808 >
5809 > eval "$as_ac_Header=no"
5810 > fi
5811 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5812 > fi
5813 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5814 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
5815 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
5816 >  cat >>confdefs.h <<_ACEOF
5817 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
5818 > _ACEOF
5819 >
5820 > fi
5821 >
5822 > done
5823 >
5824 >
5825 > #
5826 > # Handle user hints
5827 > #
5828 >
5829 > # Check whether --with-zlib or --without-zlib was given.
5830 > if test "${with_zlib+set}" = set; then
5831 >  withval="$with_zlib"
5832 >  zlib_dir="$withval"
5833 > else
5834 >                zlib_dir="not_set"
5835 > fi;
5836 > if test "$zlib_dir" != "no"; then
5837 >
5838 > if test "$zlib_dir" != "not_set" ; then
5839 >  if test -d "$zlib_dir"
5840 >  then
5841 >    ZLIB_HOME="$zlib_dir"
5842 >  else
5843 >    { echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5844 > echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5845 >  fi
5846 > fi
5847 >
5848 > ZLIB_HOME=/usr/local
5849 > if test ! -f "${ZLIB_HOME}/include/zlib.h"
5850 > then
5851 >        ZLIB_HOME=/usr
5852 > fi
5853 >
5854 > #
5855 > # Locate zlib, if wanted
5856 > #
5857 > if test -n "${ZLIB_HOME}"
5858 > then
5859 >        ZLIB_OLD_LDFLAGS=$LDFLAGS
5860 >        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5861 >        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5862 >        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
5863 >
5864 >
5865 >        ac_ext=c
5866 > ac_cpp='$CPP $CPPFLAGS'
5867 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5868 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5869 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5870 >
5871 >        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5872 > echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5873 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5874 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5875 > else
5876 >  ac_check_lib_save_LIBS=$LIBS
5877 > LIBS="-lz  $LIBS"
5878 > cat >conftest.$ac_ext <<_ACEOF
5879 > /* confdefs.h.  */
5880 > _ACEOF
5881 > cat confdefs.h >>conftest.$ac_ext
5882 > cat >>conftest.$ac_ext <<_ACEOF
5883 > /* end confdefs.h.  */
5884 >
5885 > /* Override any gcc2 internal prototype to avoid an error.  */
5886 > #ifdef __cplusplus
5887 > extern "C"
5888 > #endif
5889 > /* We use char because int might match the return type of a gcc2
5890 >   builtin and then its argument prototype would still apply.  */
5891 > char inflateEnd ();
5892 > #ifdef FC_DUMMY_MAIN
5893 > #ifndef FC_DUMMY_MAIN_EQ_F77
5894 > #  ifdef __cplusplus
5895 >     extern "C"
5896 > #  endif
5897 >   int FC_DUMMY_MAIN() { return 1; }
5898 > #endif
5899 > #endif
5900 > int
5901 > main ()
5902 > {
5903 > inflateEnd ();
5904 >  ;
5905 >  return 0;
5906 > }
5907 > _ACEOF
5908 > rm -f conftest.$ac_objext conftest$ac_exeext
5909 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5910 >  (eval $ac_link) 2>conftest.er1
5911 >  ac_status=$?
5912 >  grep -v '^ *+' conftest.er1 >conftest.err
5913 >  rm -f conftest.er1
5914 >  cat conftest.err >&5
5915 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5916 >  (exit $ac_status); } &&
5917 >         { ac_try='test -z "$ac_c_werror_flag"
5918 >                         || test ! -s conftest.err'
5919 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5920 >  (eval $ac_try) 2>&5
5921 >  ac_status=$?
5922 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5923 >  (exit $ac_status); }; } &&
5924 >         { ac_try='test -s conftest$ac_exeext'
5925 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5926 >  (eval $ac_try) 2>&5
5927 >  ac_status=$?
5928 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5929 >  (exit $ac_status); }; }; then
5930 >  ac_cv_lib_z_inflateEnd=yes
5931 > else
5932 >  echo "$as_me: failed program was:" >&5
5933 > sed 's/^/| /' conftest.$ac_ext >&5
5934 >
5935 > ac_cv_lib_z_inflateEnd=no
5936 > fi
5937 > rm -f conftest.err conftest.$ac_objext \
5938 >      conftest$ac_exeext conftest.$ac_ext
5939 > LIBS=$ac_check_lib_save_LIBS
5940 > fi
5941 > echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5942 > echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5943 > if test $ac_cv_lib_z_inflateEnd = yes; then
5944 >  zlib_cv_libz=yes
5945 > else
5946 >  zlib_cv_libz=no
5947 > fi
5948 >
5949 >        if test "${ac_cv_header_zlib_h+set}" = set; then
5950 >  echo "$as_me:$LINENO: checking for zlib.h" >&5
5951 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5952 > if test "${ac_cv_header_zlib_h+set}" = set; then
5953 >  echo $ECHO_N "(cached) $ECHO_C" >&6
5954 > fi
5955 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5956 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5957 > else
5958 >  # Is the header compilable?
5959 > echo "$as_me:$LINENO: checking zlib.h usability" >&5
5960 > echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5961 > cat >conftest.$ac_ext <<_ACEOF
5962 > /* confdefs.h.  */
5963 > _ACEOF
5964 > cat confdefs.h >>conftest.$ac_ext
5965 > cat >>conftest.$ac_ext <<_ACEOF
5966 > /* end confdefs.h.  */
5967 > $ac_includes_default
5968 > #include <zlib.h>
5969 > _ACEOF
5970 > rm -f conftest.$ac_objext
5971 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5972 >  (eval $ac_compile) 2>conftest.er1
5973 >  ac_status=$?
5974 >  grep -v '^ *+' conftest.er1 >conftest.err
5975 >  rm -f conftest.er1
5976 >  cat conftest.err >&5
5977 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5978 >  (exit $ac_status); } &&
5979 >         { ac_try='test -z "$ac_c_werror_flag"
5980 >                         || test ! -s conftest.err'
5981 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5982 >  (eval $ac_try) 2>&5
5983 >  ac_status=$?
5984 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5985 >  (exit $ac_status); }; } &&
5986 >         { ac_try='test -s conftest.$ac_objext'
5987 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5988 >  (eval $ac_try) 2>&5
5989 >  ac_status=$?
5990 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5991 >  (exit $ac_status); }; }; then
5992 >  ac_header_compiler=yes
5993 > else
5994 >  echo "$as_me: failed program was:" >&5
5995 > sed 's/^/| /' conftest.$ac_ext >&5
5996 >
5997 > ac_header_compiler=no
5998 > fi
5999 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6000 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6001 > echo "${ECHO_T}$ac_header_compiler" >&6
6002 >
6003 > # Is the header present?
6004 > echo "$as_me:$LINENO: checking zlib.h presence" >&5
6005 > echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
6006 > cat >conftest.$ac_ext <<_ACEOF
6007 > /* confdefs.h.  */
6008 > _ACEOF
6009 > cat confdefs.h >>conftest.$ac_ext
6010 > cat >>conftest.$ac_ext <<_ACEOF
6011 > /* end confdefs.h.  */
6012 > #include <zlib.h>
6013 > _ACEOF
6014 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6015 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6016 >  ac_status=$?
6017 >  grep -v '^ *+' conftest.er1 >conftest.err
6018 >  rm -f conftest.er1
6019 >  cat conftest.err >&5
6020 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6021 >  (exit $ac_status); } >/dev/null; then
6022 >  if test -s conftest.err; then
6023 >    ac_cpp_err=$ac_c_preproc_warn_flag
6024 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6025 >  else
6026 >    ac_cpp_err=
6027 >  fi
6028 > else
6029 >  ac_cpp_err=yes
6030 > fi
6031 > if test -z "$ac_cpp_err"; then
6032 >  ac_header_preproc=yes
6033 > else
6034 >  echo "$as_me: failed program was:" >&5
6035 > sed 's/^/| /' conftest.$ac_ext >&5
6036 >
6037 >  ac_header_preproc=no
6038 > fi
6039 > rm -f conftest.err conftest.$ac_ext
6040 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6041 > echo "${ECHO_T}$ac_header_preproc" >&6
6042 >
6043 > # So?  What about this header?
6044 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6045 >  yes:no: )
6046 >    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
6047 > echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6048 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
6049 > echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
6050 >    ac_header_preproc=yes
6051 >    ;;
6052 >  no:yes:* )
6053 >    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
6054 > echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
6055 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
6056 > echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
6057 >    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
6058 > echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
6059 >    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
6060 > echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6061 >    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
6062 > echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
6063 >    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
6064 > echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
6065 >    (
6066 >      cat <<\_ASBOX
6067 > ## ------------------------------ ##
6068 > ## Report this to gezelter@nd.edu ##
6069 > ## ------------------------------ ##
6070 > _ASBOX
6071 >    ) |
6072 >      sed "s/^/$as_me: WARNING:     /" >&2
6073 >    ;;
6074 > esac
6075 > echo "$as_me:$LINENO: checking for zlib.h" >&5
6076 > echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
6077 > if test "${ac_cv_header_zlib_h+set}" = set; then
6078 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6079 > else
6080 >  ac_cv_header_zlib_h=$ac_header_preproc
6081 > fi
6082 > echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
6083 > echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
6084 >
6085 > fi
6086 > if test $ac_cv_header_zlib_h = yes; then
6087 >  zlib_cv_zlib_h=yes
6088 > else
6089 >  zlib_cv_zlib_h=no
6090 > fi
6091 >
6092 >
6093 >        ac_ext=c
6094 > ac_cpp='$CPP $CPPFLAGS'
6095 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6096 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6097 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6098 >
6099 >
6100 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
6101 >
6102 > cat >>confdefs.h <<\_ACEOF
6103 > #define HAVE_ZLIB_H 1
6104 > _ACEOF
6105 >
6106 >
6107 > cat >>confdefs.h <<\_ACEOF
6108 > #define HAVE_LIBZ 1
6109 > _ACEOF
6110 >
6111 >                ZLIB_INC_DIR="${ZLIB_HOME}/include"
6112 >                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
6113 >                ZLIB="-lz"
6114 >        else
6115 >                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
6116 > echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
6117 >                ZLIB_INC_DIR=
6118 >                ZLIB_LIB_DIR=
6119 >                ZLIB=
6120 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
6121 >                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
6122 >                echo "$as_me:$LINENO: result: failed" >&5
6123 > echo "${ECHO_T}failed" >&6
6124 >                echo ""
6125 >                echo "*********************************************************"
6126 >                echo "* WARNING: Could not find a working zlib installation   *"
6127 >                echo "* If you need OOPSE to be able to deal with compressed  *"
6128 >                echo "* trajectory dump files be sure to specify a valid zlib *"
6129 >                echo "* installation with --with-zlib=DIR                     *"
6130 >                echo "*                                                       *"
6131 >                echo "* OOPSE will still work without zlib installed.         *"
6132 >                echo "*********************************************************"
6133 >                echo ""
6134 >        fi
6135 >
6136 >
6137 >
6138 > fi
6139 > fi
6140 >
6141 > #
6142 > # Handle user hints
6143 > #
6144 >
6145 > # Check whether --with-fftw or --without-fftw was given.
6146 > if test "${with_fftw+set}" = set; then
6147 >  withval="$with_fftw"
6148 >  fftw_dir="$withval"
6149 > else
6150 >             fftw_dir="not_set"
6151 > fi;
6152 > if test "$fftw_dir" != "no"; then
6153 >  if test "$fftw_dir" != "not_set" ; then
6154 >    if test -d "$fftw_dir"; then
6155 >      FFTW_HOME="$fftw_dir"
6156 >    else
6157 >      { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
6158 > echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
6159 >      FFTW_HOME=/usr/local
6160 >      if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
6161 >        FFTW_HOME=/usr
6162 >      fi
6163 >    fi
6164 >    #
6165 >    # Locate fftw, if wanted
6166 >    #
6167 >    if test -n "${FFTW_HOME}"; then
6168 >      FFTW_OLD_LDFLAGS=$LDFLAGS
6169 >      FFTW_OLD_CPPFLAGS=$LDFLAGS
6170 >      LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
6171 >      CPPFLAGS="$CPPFLAGS -I${FFTW_HOME}/include"
6172 >
6173 >
6174 >      ac_ext=c
6175 > ac_cpp='$CPP $CPPFLAGS'
6176 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6177 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6178 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6179 >
6180 >      echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
6181 > echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6
6182 > if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
6183 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6184 > else
6185 >  ac_check_lib_save_LIBS=$LIBS
6186 > LIBS="-lfftw3  $LIBS"
6187 > cat >conftest.$ac_ext <<_ACEOF
6188 > /* confdefs.h.  */
6189 > _ACEOF
6190 > cat confdefs.h >>conftest.$ac_ext
6191 > cat >>conftest.$ac_ext <<_ACEOF
6192 > /* end confdefs.h.  */
6193 >
6194 > /* Override any gcc2 internal prototype to avoid an error.  */
6195 > #ifdef __cplusplus
6196 > extern "C"
6197 > #endif
6198 > /* We use char because int might match the return type of a gcc2
6199 >   builtin and then its argument prototype would still apply.  */
6200 > char fftw_execute ();
6201 > #ifdef FC_DUMMY_MAIN
6202 > #ifndef FC_DUMMY_MAIN_EQ_F77
6203 > #  ifdef __cplusplus
6204 >     extern "C"
6205 > #  endif
6206 >   int FC_DUMMY_MAIN() { return 1; }
6207 > #endif
6208 > #endif
6209 > int
6210 > main ()
6211 > {
6212 > fftw_execute ();
6213 >  ;
6214 >  return 0;
6215 > }
6216 > _ACEOF
6217 > rm -f conftest.$ac_objext conftest$ac_exeext
6218 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6219 >  (eval $ac_link) 2>conftest.er1
6220 >  ac_status=$?
6221 >  grep -v '^ *+' conftest.er1 >conftest.err
6222 >  rm -f conftest.er1
6223 >  cat conftest.err >&5
6224 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6225 >  (exit $ac_status); } &&
6226 >         { ac_try='test -z "$ac_c_werror_flag"
6227 >                         || test ! -s conftest.err'
6228 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6229 >  (eval $ac_try) 2>&5
6230 >  ac_status=$?
6231 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6232 >  (exit $ac_status); }; } &&
6233 >         { ac_try='test -s conftest$ac_exeext'
6234 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6235 >  (eval $ac_try) 2>&5
6236 >  ac_status=$?
6237 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6238 >  (exit $ac_status); }; }; then
6239 >  ac_cv_lib_fftw3_fftw_execute=yes
6240 > else
6241 >  echo "$as_me: failed program was:" >&5
6242 > sed 's/^/| /' conftest.$ac_ext >&5
6243 >
6244 > ac_cv_lib_fftw3_fftw_execute=no
6245 > fi
6246 > rm -f conftest.err conftest.$ac_objext \
6247 >      conftest$ac_exeext conftest.$ac_ext
6248 > LIBS=$ac_check_lib_save_LIBS
6249 > fi
6250 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
6251 > echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6
6252 > if test $ac_cv_lib_fftw3_fftw_execute = yes; then
6253 >  fftw_cv_libfftw3=yes
6254 > else
6255 >  fftw_cv_libfftw3=no
6256 > fi
6257 >
6258 >      if test "${ac_cv_header_fftw3_h+set}" = set; then
6259 >  echo "$as_me:$LINENO: checking for fftw3.h" >&5
6260 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6261 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6262 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6263 > fi
6264 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6265 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6266 > else
6267 >  # Is the header compilable?
6268 > echo "$as_me:$LINENO: checking fftw3.h usability" >&5
6269 > echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6
6270 > cat >conftest.$ac_ext <<_ACEOF
6271 > /* confdefs.h.  */
6272 > _ACEOF
6273 > cat confdefs.h >>conftest.$ac_ext
6274 > cat >>conftest.$ac_ext <<_ACEOF
6275 > /* end confdefs.h.  */
6276 > $ac_includes_default
6277 > #include <fftw3.h>
6278 > _ACEOF
6279 > rm -f conftest.$ac_objext
6280 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6281 >  (eval $ac_compile) 2>conftest.er1
6282 >  ac_status=$?
6283 >  grep -v '^ *+' conftest.er1 >conftest.err
6284 >  rm -f conftest.er1
6285 >  cat conftest.err >&5
6286 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6287 >  (exit $ac_status); } &&
6288 >         { ac_try='test -z "$ac_c_werror_flag"
6289 >                         || test ! -s conftest.err'
6290 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6291 >  (eval $ac_try) 2>&5
6292 >  ac_status=$?
6293 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6294 >  (exit $ac_status); }; } &&
6295 >         { ac_try='test -s conftest.$ac_objext'
6296 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6297 >  (eval $ac_try) 2>&5
6298 >  ac_status=$?
6299 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6300 >  (exit $ac_status); }; }; then
6301 >  ac_header_compiler=yes
6302 > else
6303 >  echo "$as_me: failed program was:" >&5
6304 > sed 's/^/| /' conftest.$ac_ext >&5
6305 >
6306 > ac_header_compiler=no
6307 > fi
6308 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6309 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6310 > echo "${ECHO_T}$ac_header_compiler" >&6
6311 >
6312 > # Is the header present?
6313 > echo "$as_me:$LINENO: checking fftw3.h presence" >&5
6314 > echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6
6315 > cat >conftest.$ac_ext <<_ACEOF
6316 > /* confdefs.h.  */
6317 > _ACEOF
6318 > cat confdefs.h >>conftest.$ac_ext
6319 > cat >>conftest.$ac_ext <<_ACEOF
6320 > /* end confdefs.h.  */
6321 > #include <fftw3.h>
6322 > _ACEOF
6323 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6324 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6325 >  ac_status=$?
6326 >  grep -v '^ *+' conftest.er1 >conftest.err
6327 >  rm -f conftest.er1
6328 >  cat conftest.err >&5
6329 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6330 >  (exit $ac_status); } >/dev/null; then
6331 >  if test -s conftest.err; then
6332 >    ac_cpp_err=$ac_c_preproc_warn_flag
6333 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6334 >  else
6335 >    ac_cpp_err=
6336 >  fi
6337 > else
6338 >  ac_cpp_err=yes
6339 > fi
6340 > if test -z "$ac_cpp_err"; then
6341 >  ac_header_preproc=yes
6342 > else
6343 >  echo "$as_me: failed program was:" >&5
6344 > sed 's/^/| /' conftest.$ac_ext >&5
6345 >
6346 >  ac_header_preproc=no
6347 > fi
6348 > rm -f conftest.err conftest.$ac_ext
6349 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6350 > echo "${ECHO_T}$ac_header_preproc" >&6
6351 >
6352 > # So?  What about this header?
6353 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6354 >  yes:no: )
6355 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
6356 > echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6357 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
6358 > echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
6359 >    ac_header_preproc=yes
6360 >    ;;
6361 >  no:yes:* )
6362 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
6363 > echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
6364 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
6365 > echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
6366 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
6367 > echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
6368 >    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
6369 > echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6370 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
6371 > echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
6372 >    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
6373 > echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
6374 >    (
6375 >      cat <<\_ASBOX
6376 > ## ------------------------------ ##
6377 > ## Report this to gezelter@nd.edu ##
6378 > ## ------------------------------ ##
6379 > _ASBOX
6380 >    ) |
6381 >      sed "s/^/$as_me: WARNING:     /" >&2
6382 >    ;;
6383 > esac
6384 > echo "$as_me:$LINENO: checking for fftw3.h" >&5
6385 > echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6
6386 > if test "${ac_cv_header_fftw3_h+set}" = set; then
6387 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6388 > else
6389 >  ac_cv_header_fftw3_h=$ac_header_preproc
6390 > fi
6391 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
6392 > echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6
6393 >
6394 > fi
6395 > if test $ac_cv_header_fftw3_h = yes; then
6396 >  fftw_cv_fftw3_h=yes
6397 > else
6398 >  fftw_cv_fftw3_h=no
6399 > fi
6400 >
6401 >
6402 >      if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
6403 >        echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
6404 > echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6
6405 > if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
6406 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6407 > else
6408 >  ac_check_lib_save_LIBS=$LIBS
6409 > LIBS="-lfftw  $LIBS"
6410 > cat >conftest.$ac_ext <<_ACEOF
6411 > /* confdefs.h.  */
6412 > _ACEOF
6413 > cat confdefs.h >>conftest.$ac_ext
6414 > cat >>conftest.$ac_ext <<_ACEOF
6415 > /* end confdefs.h.  */
6416 >
6417 > /* Override any gcc2 internal prototype to avoid an error.  */
6418 > #ifdef __cplusplus
6419 > extern "C"
6420 > #endif
6421 > /* We use char because int might match the return type of a gcc2
6422 >   builtin and then its argument prototype would still apply.  */
6423 > char fftwnd_one ();
6424 > #ifdef FC_DUMMY_MAIN
6425 > #ifndef FC_DUMMY_MAIN_EQ_F77
6426 > #  ifdef __cplusplus
6427 >     extern "C"
6428 > #  endif
6429 >   int FC_DUMMY_MAIN() { return 1; }
6430 > #endif
6431 > #endif
6432 > int
6433 > main ()
6434 > {
6435 > fftwnd_one ();
6436 >  ;
6437 >  return 0;
6438 > }
6439 > _ACEOF
6440 > rm -f conftest.$ac_objext conftest$ac_exeext
6441 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6442 >  (eval $ac_link) 2>conftest.er1
6443 >  ac_status=$?
6444 >  grep -v '^ *+' conftest.er1 >conftest.err
6445 >  rm -f conftest.er1
6446 >  cat conftest.err >&5
6447 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6448 >  (exit $ac_status); } &&
6449 >         { ac_try='test -z "$ac_c_werror_flag"
6450 >                         || test ! -s conftest.err'
6451 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6452 >  (eval $ac_try) 2>&5
6453 >  ac_status=$?
6454 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6455 >  (exit $ac_status); }; } &&
6456 >         { ac_try='test -s conftest$ac_exeext'
6457 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6458 >  (eval $ac_try) 2>&5
6459 >  ac_status=$?
6460 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6461 >  (exit $ac_status); }; }; then
6462 >  ac_cv_lib_fftw_fftwnd_one=yes
6463 > else
6464 >  echo "$as_me: failed program was:" >&5
6465 > sed 's/^/| /' conftest.$ac_ext >&5
6466 >
6467 > ac_cv_lib_fftw_fftwnd_one=no
6468 > fi
6469 > rm -f conftest.err conftest.$ac_objext \
6470 >      conftest$ac_exeext conftest.$ac_ext
6471 > LIBS=$ac_check_lib_save_LIBS
6472 > fi
6473 > echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
6474 > echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6
6475 > if test $ac_cv_lib_fftw_fftwnd_one = yes; then
6476 >  fftw_cv_libfftw=yes
6477 > else
6478 >  fftw_cv_libfftw=no
6479 > fi
6480 >
6481 >        if test "${ac_cv_header_fftw_h+set}" = set; then
6482 >  echo "$as_me:$LINENO: checking for fftw.h" >&5
6483 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6484 > if test "${ac_cv_header_fftw_h+set}" = set; then
6485 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6486 > fi
6487 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6488 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6489 > else
6490 >  # Is the header compilable?
6491 > echo "$as_me:$LINENO: checking fftw.h usability" >&5
6492 > echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6
6493 > cat >conftest.$ac_ext <<_ACEOF
6494 > /* confdefs.h.  */
6495 > _ACEOF
6496 > cat confdefs.h >>conftest.$ac_ext
6497 > cat >>conftest.$ac_ext <<_ACEOF
6498 > /* end confdefs.h.  */
6499 > $ac_includes_default
6500 > #include <fftw.h>
6501 > _ACEOF
6502 > rm -f conftest.$ac_objext
6503 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6504 >  (eval $ac_compile) 2>conftest.er1
6505 >  ac_status=$?
6506 >  grep -v '^ *+' conftest.er1 >conftest.err
6507 >  rm -f conftest.er1
6508 >  cat conftest.err >&5
6509 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6510 >  (exit $ac_status); } &&
6511 >         { ac_try='test -z "$ac_c_werror_flag"
6512 >                         || test ! -s conftest.err'
6513 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6514 >  (eval $ac_try) 2>&5
6515 >  ac_status=$?
6516 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6517 >  (exit $ac_status); }; } &&
6518 >         { ac_try='test -s conftest.$ac_objext'
6519 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6520 >  (eval $ac_try) 2>&5
6521 >  ac_status=$?
6522 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6523 >  (exit $ac_status); }; }; then
6524 >  ac_header_compiler=yes
6525 > else
6526 >  echo "$as_me: failed program was:" >&5
6527 > sed 's/^/| /' conftest.$ac_ext >&5
6528 >
6529 > ac_header_compiler=no
6530 > fi
6531 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6532 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6533 > echo "${ECHO_T}$ac_header_compiler" >&6
6534 >
6535 > # Is the header present?
6536 > echo "$as_me:$LINENO: checking fftw.h presence" >&5
6537 > echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6
6538 > cat >conftest.$ac_ext <<_ACEOF
6539 > /* confdefs.h.  */
6540 > _ACEOF
6541 > cat confdefs.h >>conftest.$ac_ext
6542 > cat >>conftest.$ac_ext <<_ACEOF
6543 > /* end confdefs.h.  */
6544 > #include <fftw.h>
6545 > _ACEOF
6546 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6547 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6548 >  ac_status=$?
6549 >  grep -v '^ *+' conftest.er1 >conftest.err
6550 >  rm -f conftest.er1
6551 >  cat conftest.err >&5
6552 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6553 >  (exit $ac_status); } >/dev/null; then
6554 >  if test -s conftest.err; then
6555 >    ac_cpp_err=$ac_c_preproc_warn_flag
6556 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6557 >  else
6558 >    ac_cpp_err=
6559 >  fi
6560 > else
6561 >  ac_cpp_err=yes
6562 > fi
6563 > if test -z "$ac_cpp_err"; then
6564 >  ac_header_preproc=yes
6565 > else
6566 >  echo "$as_me: failed program was:" >&5
6567 > sed 's/^/| /' conftest.$ac_ext >&5
6568 >
6569 >  ac_header_preproc=no
6570 > fi
6571 > rm -f conftest.err conftest.$ac_ext
6572 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6573 > echo "${ECHO_T}$ac_header_preproc" >&6
6574 >
6575 > # So?  What about this header?
6576 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6577 >  yes:no: )
6578 >    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6579 > echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6580 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
6581 > echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
6582 >    ac_header_preproc=yes
6583 >    ;;
6584 >  no:yes:* )
6585 >    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
6586 > echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
6587 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
6588 > echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
6589 >    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
6590 > echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
6591 >    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6592 > echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6593 >    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
6594 > echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
6595 >    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
6596 > echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
6597 >    (
6598 >      cat <<\_ASBOX
6599 > ## ------------------------------ ##
6600 > ## Report this to gezelter@nd.edu ##
6601 > ## ------------------------------ ##
6602 > _ASBOX
6603 >    ) |
6604 >      sed "s/^/$as_me: WARNING:     /" >&2
6605 >    ;;
6606 > esac
6607 > echo "$as_me:$LINENO: checking for fftw.h" >&5
6608 > echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6
6609 > if test "${ac_cv_header_fftw_h+set}" = set; then
6610 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6611 > else
6612 >  ac_cv_header_fftw_h=$ac_header_preproc
6613 > fi
6614 > echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
6615 > echo "${ECHO_T}$ac_cv_header_fftw_h" >&6
6616 >
6617 > fi
6618 > if test $ac_cv_header_fftw_h = yes; then
6619 >  fftw_cv_fftw_h=yes
6620 > else
6621 >  fftw_cv_fftw_h=no
6622 > fi
6623 >
6624 >
6625 >        if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
6626 >          echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
6627 > echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6
6628 > if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
6629 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6630 > else
6631 >  ac_check_lib_save_LIBS=$LIBS
6632 > LIBS="-ldfftw  $LIBS"
6633 > cat >conftest.$ac_ext <<_ACEOF
6634 > /* confdefs.h.  */
6635 > _ACEOF
6636 > cat confdefs.h >>conftest.$ac_ext
6637 > cat >>conftest.$ac_ext <<_ACEOF
6638 > /* end confdefs.h.  */
6639 >
6640 > /* Override any gcc2 internal prototype to avoid an error.  */
6641 > #ifdef __cplusplus
6642 > extern "C"
6643 > #endif
6644 > /* We use char because int might match the return type of a gcc2
6645 >   builtin and then its argument prototype would still apply.  */
6646 > char fftwnd_one ();
6647 > #ifdef FC_DUMMY_MAIN
6648 > #ifndef FC_DUMMY_MAIN_EQ_F77
6649 > #  ifdef __cplusplus
6650 >     extern "C"
6651 > #  endif
6652 >   int FC_DUMMY_MAIN() { return 1; }
6653 > #endif
6654 > #endif
6655 > int
6656 > main ()
6657 > {
6658 > fftwnd_one ();
6659 >  ;
6660 >  return 0;
6661 > }
6662 > _ACEOF
6663 > rm -f conftest.$ac_objext conftest$ac_exeext
6664 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6665 >  (eval $ac_link) 2>conftest.er1
6666 >  ac_status=$?
6667 >  grep -v '^ *+' conftest.er1 >conftest.err
6668 >  rm -f conftest.er1
6669 >  cat conftest.err >&5
6670 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6671 >  (exit $ac_status); } &&
6672 >         { ac_try='test -z "$ac_c_werror_flag"
6673 >                         || test ! -s conftest.err'
6674 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6675 >  (eval $ac_try) 2>&5
6676 >  ac_status=$?
6677 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6678 >  (exit $ac_status); }; } &&
6679 >         { ac_try='test -s conftest$ac_exeext'
6680 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6681 >  (eval $ac_try) 2>&5
6682 >  ac_status=$?
6683 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6684 >  (exit $ac_status); }; }; then
6685 >  ac_cv_lib_dfftw_fftwnd_one=yes
6686 > else
6687 >  echo "$as_me: failed program was:" >&5
6688 > sed 's/^/| /' conftest.$ac_ext >&5
6689 >
6690 > ac_cv_lib_dfftw_fftwnd_one=no
6691 > fi
6692 > rm -f conftest.err conftest.$ac_objext \
6693 >      conftest$ac_exeext conftest.$ac_ext
6694 > LIBS=$ac_check_lib_save_LIBS
6695 > fi
6696 > echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
6697 > echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6
6698 > if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
6699 >  fftw_cv_libdfftw=yes
6700 > else
6701 >  fftw_cv_libdfftw=no
6702 > fi
6703 >
6704 >          if test "${ac_cv_header_dfftw_h+set}" = set; then
6705 >  echo "$as_me:$LINENO: checking for dfftw.h" >&5
6706 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6707 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6708 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6709 > fi
6710 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6711 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6712 > else
6713 >  # Is the header compilable?
6714 > echo "$as_me:$LINENO: checking dfftw.h usability" >&5
6715 > echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6
6716 > cat >conftest.$ac_ext <<_ACEOF
6717 > /* confdefs.h.  */
6718 > _ACEOF
6719 > cat confdefs.h >>conftest.$ac_ext
6720 > cat >>conftest.$ac_ext <<_ACEOF
6721 > /* end confdefs.h.  */
6722 > $ac_includes_default
6723 > #include <dfftw.h>
6724 > _ACEOF
6725 > rm -f conftest.$ac_objext
6726 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6727 >  (eval $ac_compile) 2>conftest.er1
6728 >  ac_status=$?
6729 >  grep -v '^ *+' conftest.er1 >conftest.err
6730 >  rm -f conftest.er1
6731 >  cat conftest.err >&5
6732 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6733 >  (exit $ac_status); } &&
6734 >         { ac_try='test -z "$ac_c_werror_flag"
6735 >                         || test ! -s conftest.err'
6736 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6737 >  (eval $ac_try) 2>&5
6738 >  ac_status=$?
6739 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6740 >  (exit $ac_status); }; } &&
6741 >         { ac_try='test -s conftest.$ac_objext'
6742 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6743 >  (eval $ac_try) 2>&5
6744 >  ac_status=$?
6745 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6746 >  (exit $ac_status); }; }; then
6747 >  ac_header_compiler=yes
6748 > else
6749 >  echo "$as_me: failed program was:" >&5
6750 > sed 's/^/| /' conftest.$ac_ext >&5
6751 >
6752 > ac_header_compiler=no
6753 > fi
6754 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6755 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6756 > echo "${ECHO_T}$ac_header_compiler" >&6
6757 >
6758 > # Is the header present?
6759 > echo "$as_me:$LINENO: checking dfftw.h presence" >&5
6760 > echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6
6761 > cat >conftest.$ac_ext <<_ACEOF
6762 > /* confdefs.h.  */
6763 > _ACEOF
6764 > cat confdefs.h >>conftest.$ac_ext
6765 > cat >>conftest.$ac_ext <<_ACEOF
6766 > /* end confdefs.h.  */
6767 > #include <dfftw.h>
6768 > _ACEOF
6769 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
6770 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
6771 >  ac_status=$?
6772 >  grep -v '^ *+' conftest.er1 >conftest.err
6773 >  rm -f conftest.er1
6774 >  cat conftest.err >&5
6775 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6776 >  (exit $ac_status); } >/dev/null; then
6777 >  if test -s conftest.err; then
6778 >    ac_cpp_err=$ac_c_preproc_warn_flag
6779 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
6780 >  else
6781 >    ac_cpp_err=
6782 >  fi
6783 > else
6784 >  ac_cpp_err=yes
6785 > fi
6786 > if test -z "$ac_cpp_err"; then
6787 >  ac_header_preproc=yes
6788 > else
6789 >  echo "$as_me: failed program was:" >&5
6790 > sed 's/^/| /' conftest.$ac_ext >&5
6791 >
6792 >  ac_header_preproc=no
6793 > fi
6794 > rm -f conftest.err conftest.$ac_ext
6795 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
6796 > echo "${ECHO_T}$ac_header_preproc" >&6
6797 >
6798 > # So?  What about this header?
6799 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6800 >  yes:no: )
6801 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
6802 > echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
6803 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
6804 > echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
6805 >    ac_header_preproc=yes
6806 >    ;;
6807 >  no:yes:* )
6808 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
6809 > echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
6810 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
6811 > echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
6812 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
6813 > echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
6814 >    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
6815 > echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
6816 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
6817 > echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
6818 >    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
6819 > echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
6820 >    (
6821 >      cat <<\_ASBOX
6822 > ## ------------------------------ ##
6823 > ## Report this to gezelter@nd.edu ##
6824 > ## ------------------------------ ##
6825 > _ASBOX
6826 >    ) |
6827 >      sed "s/^/$as_me: WARNING:     /" >&2
6828 >    ;;
6829 > esac
6830 > echo "$as_me:$LINENO: checking for dfftw.h" >&5
6831 > echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6
6832 > if test "${ac_cv_header_dfftw_h+set}" = set; then
6833 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6834 > else
6835 >  ac_cv_header_dfftw_h=$ac_header_preproc
6836 > fi
6837 > echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
6838 > echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6
6839 >
6840 > fi
6841 > if test $ac_cv_header_dfftw_h = yes; then
6842 >  fftw_cv_dfftw_h=yes
6843 > else
6844 >  fftw_cv_dfftw_h=no
6845 > fi
6846 >
6847 >
6848 >        fi
6849 >      fi
6850 >      ac_ext=c
6851 > ac_cpp='$CPP $CPPFLAGS'
6852 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6853 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6854 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6855 >
6856 >      if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
6857 >
6858 > cat >>confdefs.h <<\_ACEOF
6859 > #define HAVE_FFTW3_H 1
6860 > _ACEOF
6861 >
6862 >        FFTW_INC_DIR="${FFTW_HOME}/include"
6863 >        FFTW_LIB_DIR="${FFTW_HOME}/lib"
6864 >        FFTW_LIBS="-lfftw3"
6865 >      else
6866 >        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
6867 >
6868 > cat >>confdefs.h <<\_ACEOF
6869 > #define HAVE_FFTW_H 1
6870 > _ACEOF
6871 >
6872 >          FFTW_INC_DIR="${FFTW_HOME}/include"
6873 >          FFTW_LIB_DIR="${FFTW_HOME}/lib"
6874 >          FFTW_LIBS="-lfftw"
6875 >        else
6876 >          if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
6877 >
6878 > cat >>confdefs.h <<\_ACEOF
6879 > #define HAVE_DFFTW_H 1
6880 > _ACEOF
6881 >
6882 >            FFTW_INC_DIR="${FFTW_HOME}/include"
6883 >            FFTW_LIB_DIR="${FFTW_HOME}/lib"
6884 >            FFTW_LIBS="-ldfftw"
6885 >          else
6886 >            echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
6887 > echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6
6888 >            FFTW_INC_DIR=
6889 >            FFTW_LIB_DIR=
6890 >            FFTW_LIBS=
6891 >            LDFLAGS="$FFTW_OLD_LDFLAGS"
6892 >            CPPFLAGS="$FFTW_OLD_CPPFLAGS"
6893 >            echo "$as_me:$LINENO: result: failed" >&5
6894 > echo "${ECHO_T}failed" >&6
6895 >            echo ""
6896 >            echo "*********************************************************"
6897 >            echo "* WARNING: Could not find a working FFTW installation   *"
6898 >            echo "* If you need the staticProps program to be able to     *"
6899 >            echo "* compute undulation spectra, be sure to specify a      *"
6900 >            echo "* valid fftw installation with --with-fftw=DIR          *"
6901 >            echo "*                                                       *"
6902 >            echo "* OOPSE will still work without fftw installed.         *"
6903 >            echo "*********************************************************"
6904 >            echo ""
6905 >          fi
6906 >        fi
6907 >      fi
6908 >
6909 >
6910 >
6911 >    fi
6912 >  fi
6913 > fi
6914 >
6915 >
6916 >
6917 > # Checks for header files.
6918 > echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6919 > echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
6920 > if test "${ac_cv_header_stdc+set}" = set; then
6921 >  echo $ECHO_N "(cached) $ECHO_C" >&6
6922 > else
6923 >  cat >conftest.$ac_ext <<_ACEOF
6924 > /* confdefs.h.  */
6925 > _ACEOF
6926 > cat confdefs.h >>conftest.$ac_ext
6927 > cat >>conftest.$ac_ext <<_ACEOF
6928 > /* end confdefs.h.  */
6929 > #include <stdlib.h>
6930 > #include <stdarg.h>
6931 > #include <string.h>
6932 > #include <float.h>
6933 >
6934 > #ifdef FC_DUMMY_MAIN
6935 > #ifndef FC_DUMMY_MAIN_EQ_F77
6936 > #  ifdef __cplusplus
6937 >     extern "C"
6938 > #  endif
6939 >   int FC_DUMMY_MAIN() { return 1; }
6940 > #endif
6941 > #endif
6942 > int
6943 > main ()
6944 > {
6945 >
6946 >  ;
6947 >  return 0;
6948 > }
6949 > _ACEOF
6950 > rm -f conftest.$ac_objext
6951 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6952 >  (eval $ac_compile) 2>conftest.er1
6953 >  ac_status=$?
6954 >  grep -v '^ *+' conftest.er1 >conftest.err
6955 >  rm -f conftest.er1
6956 >  cat conftest.err >&5
6957 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6958 >  (exit $ac_status); } &&
6959 >         { ac_try='test -z "$ac_c_werror_flag"
6960 >                         || test ! -s conftest.err'
6961 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6962 >  (eval $ac_try) 2>&5
6963 >  ac_status=$?
6964 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6965 >  (exit $ac_status); }; } &&
6966 >         { ac_try='test -s conftest.$ac_objext'
6967 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6968 >  (eval $ac_try) 2>&5
6969 >  ac_status=$?
6970 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6971 >  (exit $ac_status); }; }; then
6972 >  ac_cv_header_stdc=yes
6973 > else
6974 >  echo "$as_me: failed program was:" >&5
6975 > sed 's/^/| /' conftest.$ac_ext >&5
6976 >
6977 > ac_cv_header_stdc=no
6978 > fi
6979 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6980 >
6981 > if test $ac_cv_header_stdc = yes; then
6982 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6983 >  cat >conftest.$ac_ext <<_ACEOF
6984 > /* confdefs.h.  */
6985 > _ACEOF
6986 > cat confdefs.h >>conftest.$ac_ext
6987 > cat >>conftest.$ac_ext <<_ACEOF
6988 > /* end confdefs.h.  */
6989 > #include <string.h>
6990 >
6991 > _ACEOF
6992 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6993 >  $EGREP "memchr" >/dev/null 2>&1; then
6994 >  :
6995 > else
6996 >  ac_cv_header_stdc=no
6997 > fi
6998 > rm -f conftest*
6999 >
7000 > fi
7001 >
7002 > if test $ac_cv_header_stdc = yes; then
7003 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7004 >  cat >conftest.$ac_ext <<_ACEOF
7005 > /* confdefs.h.  */
7006 > _ACEOF
7007 > cat confdefs.h >>conftest.$ac_ext
7008 > cat >>conftest.$ac_ext <<_ACEOF
7009 > /* end confdefs.h.  */
7010 > #include <stdlib.h>
7011 >
7012 > _ACEOF
7013 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7014 >  $EGREP "free" >/dev/null 2>&1; then
7015 >  :
7016 > else
7017 >  ac_cv_header_stdc=no
7018 > fi
7019 > rm -f conftest*
7020 >
7021 > fi
7022 >
7023 > if test $ac_cv_header_stdc = yes; then
7024 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7025 >  if test "$cross_compiling" = yes; then
7026 >  :
7027 > else
7028 >  cat >conftest.$ac_ext <<_ACEOF
7029 > /* confdefs.h.  */
7030 > _ACEOF
7031 > cat confdefs.h >>conftest.$ac_ext
7032 > cat >>conftest.$ac_ext <<_ACEOF
7033 > /* end confdefs.h.  */
7034 > #include <ctype.h>
7035 > #if ((' ' & 0x0FF) == 0x020)
7036 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7037 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7038 > #else
7039 > # define ISLOWER(c) \
7040 >                   (('a' <= (c) && (c) <= 'i') \
7041 >                     || ('j' <= (c) && (c) <= 'r') \
7042 >                     || ('s' <= (c) && (c) <= 'z'))
7043 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7044 > #endif
7045 >
7046 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7047 > int
7048 > main ()
7049 > {
7050 >  int i;
7051 >  for (i = 0; i < 256; i++)
7052 >    if (XOR (islower (i), ISLOWER (i))
7053 >        || toupper (i) != TOUPPER (i))
7054 >      exit(2);
7055 >  exit (0);
7056 > }
7057 > _ACEOF
7058 > rm -f conftest$ac_exeext
7059 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7060 >  (eval $ac_link) 2>&5
7061 >  ac_status=$?
7062 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7063 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7064 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7065 >  (eval $ac_try) 2>&5
7066 >  ac_status=$?
7067 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7068 >  (exit $ac_status); }; }; then
7069 >  :
7070 > else
7071 >  echo "$as_me: program exited with status $ac_status" >&5
7072 > echo "$as_me: failed program was:" >&5
7073 > sed 's/^/| /' conftest.$ac_ext >&5
7074 >
7075 > ( exit $ac_status )
7076 > ac_cv_header_stdc=no
7077 > fi
7078 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7079 > fi
7080 > fi
7081 > fi
7082 > echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7083 > echo "${ECHO_T}$ac_cv_header_stdc" >&6
7084 > if test $ac_cv_header_stdc = yes; then
7085 >
7086 > cat >>confdefs.h <<\_ACEOF
7087 > #define STDC_HEADERS 1
7088 > _ACEOF
7089 >
7090 > fi
7091 >
7092 >
7093 >
7094 >
7095 >
7096 >
7097 >
7098 >
7099 >
7100 >
7101 >
7102 >
7103 >
7104 >
7105 >
7106 >
7107 >
7108 >
7109 >
7110 >
7111 >
7112 >
7113 >
7114 >
7115 >
7116 >
7117 > 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
7118 > do
7119 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7120 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7121 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
7122 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7123 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7124 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7125 > fi
7126 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7127 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7128 > else
7129 >  # Is the header compilable?
7130 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
7131 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
7132 > cat >conftest.$ac_ext <<_ACEOF
7133 > /* confdefs.h.  */
7134 > _ACEOF
7135 > cat confdefs.h >>conftest.$ac_ext
7136 > cat >>conftest.$ac_ext <<_ACEOF
7137 > /* end confdefs.h.  */
7138 > $ac_includes_default
7139 > #include <$ac_header>
7140 > _ACEOF
7141 > rm -f conftest.$ac_objext
7142 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7143 >  (eval $ac_compile) 2>conftest.er1
7144 >  ac_status=$?
7145 >  grep -v '^ *+' conftest.er1 >conftest.err
7146 >  rm -f conftest.er1
7147 >  cat conftest.err >&5
7148 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7149 >  (exit $ac_status); } &&
7150 >         { ac_try='test -z "$ac_c_werror_flag"
7151 >                         || test ! -s conftest.err'
7152 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7153 >  (eval $ac_try) 2>&5
7154 >  ac_status=$?
7155 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7156 >  (exit $ac_status); }; } &&
7157 >         { ac_try='test -s conftest.$ac_objext'
7158 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7159 >  (eval $ac_try) 2>&5
7160 >  ac_status=$?
7161 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7162 >  (exit $ac_status); }; }; then
7163 >  ac_header_compiler=yes
7164 > else
7165 >  echo "$as_me: failed program was:" >&5
7166 > sed 's/^/| /' conftest.$ac_ext >&5
7167 >
7168 > ac_header_compiler=no
7169 > fi
7170 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7171 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7172 > echo "${ECHO_T}$ac_header_compiler" >&6
7173 >
7174 > # Is the header present?
7175 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
7176 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
7177 > cat >conftest.$ac_ext <<_ACEOF
7178 > /* confdefs.h.  */
7179 > _ACEOF
7180 > cat confdefs.h >>conftest.$ac_ext
7181 > cat >>conftest.$ac_ext <<_ACEOF
7182 > /* end confdefs.h.  */
7183 > #include <$ac_header>
7184 > _ACEOF
7185 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
7186 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
7187 >  ac_status=$?
7188 >  grep -v '^ *+' conftest.er1 >conftest.err
7189 >  rm -f conftest.er1
7190 >  cat conftest.err >&5
7191 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7192 >  (exit $ac_status); } >/dev/null; then
7193 >  if test -s conftest.err; then
7194 >    ac_cpp_err=$ac_c_preproc_warn_flag
7195 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
7196 >  else
7197 >    ac_cpp_err=
7198 >  fi
7199 > else
7200 >  ac_cpp_err=yes
7201 > fi
7202 > if test -z "$ac_cpp_err"; then
7203 >  ac_header_preproc=yes
7204 > else
7205 >  echo "$as_me: failed program was:" >&5
7206 > sed 's/^/| /' conftest.$ac_ext >&5
7207 >
7208 >  ac_header_preproc=no
7209 > fi
7210 > rm -f conftest.err conftest.$ac_ext
7211 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7212 > echo "${ECHO_T}$ac_header_preproc" >&6
7213 >
7214 > # So?  What about this header?
7215 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7216 >  yes:no: )
7217 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
7218 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
7219 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
7220 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
7221 >    ac_header_preproc=yes
7222 >    ;;
7223 >  no:yes:* )
7224 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
7225 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
7226 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
7227 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
7228 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
7229 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
7230 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
7231 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
7232 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
7233 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
7234 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
7235 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
7236 >    (
7237 >      cat <<\_ASBOX
7238 > ## ------------------------------ ##
7239 > ## Report this to gezelter@nd.edu ##
7240 > ## ------------------------------ ##
7241 > _ASBOX
7242 >    ) |
7243 >      sed "s/^/$as_me: WARNING:     /" >&2
7244 >    ;;
7245 > esac
7246 > echo "$as_me:$LINENO: checking for $ac_header" >&5
7247 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
7248 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
7249 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7250 > else
7251 >  eval "$as_ac_Header=\$ac_header_preproc"
7252 > fi
7253 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
7254 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
7255 >
7256 > fi
7257 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
7258 >  cat >>confdefs.h <<_ACEOF
7259 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7260 > _ACEOF
7261 >
7262 > fi
7263 >
7264 > done
7265 >
7266 >
7267 > # Checks for typedefs, structures, and compiler characteristics.
7268 > echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
7269 > echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6
7270 > if test "${ac_cv_header_stdbool_h+set}" = set; then
7271 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7272 > else
7273 >  cat >conftest.$ac_ext <<_ACEOF
7274 > /* confdefs.h.  */
7275 > _ACEOF
7276 > cat confdefs.h >>conftest.$ac_ext
7277 > cat >>conftest.$ac_ext <<_ACEOF
7278 > /* end confdefs.h.  */
7279 >
7280 > #include <stdbool.h>
7281 > #ifndef bool
7282 > # error bool is not defined
7283 > #endif
7284 > #ifndef false
7285 > # error false is not defined
7286 > #endif
7287 > #if false
7288 > # error false is not 0
7289 > #endif
7290 > #ifndef true
7291 > # error true is not defined
7292 > #endif
7293 > #if true != 1
7294 > # error true is not 1
7295 > #endif
7296 > #ifndef __bool_true_false_are_defined
7297 > # error __bool_true_false_are_defined is not defined
7298 > #endif
7299 >
7300 >        struct s { _Bool s: 1; _Bool t; } s;
7301 >
7302 >        char a[true == 1 ? 1 : -1];
7303 >        char b[false == 0 ? 1 : -1];
7304 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
7305 >        char d[(bool) -0.5 == true ? 1 : -1];
7306 >        bool e = &s;
7307 >        char f[(_Bool) -0.0 == false ? 1 : -1];
7308 >        char g[true];
7309 >        char h[sizeof (_Bool)];
7310 >        char i[sizeof s.t];
7311 >
7312 > #ifdef FC_DUMMY_MAIN
7313 > #ifndef FC_DUMMY_MAIN_EQ_F77
7314 > #  ifdef __cplusplus
7315 >     extern "C"
7316 > #  endif
7317 >   int FC_DUMMY_MAIN() { return 1; }
7318 > #endif
7319 > #endif
7320 > int
7321 > main ()
7322 > {
7323 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7324 >  ;
7325 >  return 0;
7326 > }
7327 > _ACEOF
7328 > rm -f conftest.$ac_objext
7329 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7330 >  (eval $ac_compile) 2>conftest.er1
7331 >  ac_status=$?
7332 >  grep -v '^ *+' conftest.er1 >conftest.err
7333 >  rm -f conftest.er1
7334 >  cat conftest.err >&5
7335 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7336 >  (exit $ac_status); } &&
7337 >         { ac_try='test -z "$ac_c_werror_flag"
7338 >                         || test ! -s conftest.err'
7339 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7340 >  (eval $ac_try) 2>&5
7341 >  ac_status=$?
7342 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7343 >  (exit $ac_status); }; } &&
7344 >         { ac_try='test -s conftest.$ac_objext'
7345 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7346 >  (eval $ac_try) 2>&5
7347 >  ac_status=$?
7348 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7349 >  (exit $ac_status); }; }; then
7350 >  ac_cv_header_stdbool_h=yes
7351 > else
7352 >  echo "$as_me: failed program was:" >&5
7353 > sed 's/^/| /' conftest.$ac_ext >&5
7354 >
7355 > ac_cv_header_stdbool_h=no
7356 > fi
7357 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7358 > fi
7359 > echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
7360 > echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6
7361 > echo "$as_me:$LINENO: checking for _Bool" >&5
7362 > echo $ECHO_N "checking for _Bool... $ECHO_C" >&6
7363 > if test "${ac_cv_type__Bool+set}" = set; then
7364 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7365 > else
7366 >  cat >conftest.$ac_ext <<_ACEOF
7367 > /* confdefs.h.  */
7368 > _ACEOF
7369 > cat confdefs.h >>conftest.$ac_ext
7370 > cat >>conftest.$ac_ext <<_ACEOF
7371 > /* end confdefs.h.  */
7372 > $ac_includes_default
7373 > #ifdef FC_DUMMY_MAIN
7374 > #ifndef FC_DUMMY_MAIN_EQ_F77
7375 > #  ifdef __cplusplus
7376 >     extern "C"
7377 > #  endif
7378 >   int FC_DUMMY_MAIN() { return 1; }
7379 > #endif
7380 > #endif
7381 > int
7382 > main ()
7383 > {
7384 > if ((_Bool *) 0)
7385 >  return 0;
7386 > if (sizeof (_Bool))
7387 >  return 0;
7388 >  ;
7389 >  return 0;
7390 > }
7391 > _ACEOF
7392 > rm -f conftest.$ac_objext
7393 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7394 >  (eval $ac_compile) 2>conftest.er1
7395 >  ac_status=$?
7396 >  grep -v '^ *+' conftest.er1 >conftest.err
7397 >  rm -f conftest.er1
7398 >  cat conftest.err >&5
7399 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7400 >  (exit $ac_status); } &&
7401 >         { ac_try='test -z "$ac_c_werror_flag"
7402 >                         || test ! -s conftest.err'
7403 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7404 >  (eval $ac_try) 2>&5
7405 >  ac_status=$?
7406 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7407 >  (exit $ac_status); }; } &&
7408 >         { ac_try='test -s conftest.$ac_objext'
7409 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7410 >  (eval $ac_try) 2>&5
7411 >  ac_status=$?
7412 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7413 >  (exit $ac_status); }; }; then
7414 >  ac_cv_type__Bool=yes
7415 > else
7416 >  echo "$as_me: failed program was:" >&5
7417 > sed 's/^/| /' conftest.$ac_ext >&5
7418 >
7419 > ac_cv_type__Bool=no
7420 > fi
7421 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7422 > fi
7423 > echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
7424 > echo "${ECHO_T}$ac_cv_type__Bool" >&6
7425 > if test $ac_cv_type__Bool = yes; then
7426 >
7427 > cat >>confdefs.h <<_ACEOF
7428 > #define HAVE__BOOL 1
7429 > _ACEOF
7430 >
7431 >
7432 > fi
7433 >
7434 > if test $ac_cv_header_stdbool_h = yes; then
7435 >
7436 > cat >>confdefs.h <<\_ACEOF
7437 > #define HAVE_STDBOOL_H 1
7438 > _ACEOF
7439 >
7440 > fi
7441 >
7442 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7443 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7444 > if test "${ac_cv_c_const+set}" = set; then
7445 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7446 > else
7447 >  cat >conftest.$ac_ext <<_ACEOF
7448 > /* confdefs.h.  */
7449 > _ACEOF
7450 > cat confdefs.h >>conftest.$ac_ext
7451 > cat >>conftest.$ac_ext <<_ACEOF
7452 > /* end confdefs.h.  */
7453 >
7454 > #ifdef FC_DUMMY_MAIN
7455 > #ifndef FC_DUMMY_MAIN_EQ_F77
7456 > #  ifdef __cplusplus
7457 >     extern "C"
7458 > #  endif
7459 >   int FC_DUMMY_MAIN() { return 1; }
7460 > #endif
7461 > #endif
7462 > int
7463 > main ()
7464 > {
7465 > /* FIXME: Include the comments suggested by Paul. */
7466 > #ifndef __cplusplus
7467 >  /* Ultrix mips cc rejects this.  */
7468 >  typedef int charset[2];
7469 >  const charset x;
7470 >  /* SunOS 4.1.1 cc rejects this.  */
7471 >  char const *const *ccp;
7472 >  char **p;
7473 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7474 >  struct point {int x, y;};
7475 >  static struct point const zero = {0,0};
7476 >  /* AIX XL C 1.02.0.0 rejects this.
7477 >     It does not let you subtract one const X* pointer from another in
7478 >     an arm of an if-expression whose if-part is not a constant
7479 >     expression */
7480 >  const char *g = "string";
7481 >  ccp = &g + (g ? g-g : 0);
7482 >  /* HPUX 7.0 cc rejects these. */
7483 >  ++ccp;
7484 >  p = (char**) ccp;
7485 >  ccp = (char const *const *) p;
7486 >  { /* SCO 3.2v4 cc rejects this.  */
7487 >    char *t;
7488 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7489 >
7490 >    *t++ = 0;
7491 >  }
7492 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7493 >    int x[] = {25, 17};
7494 >    const int *foo = &x[0];
7495 >    ++foo;
7496 >  }
7497 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7498 >    typedef const int *iptr;
7499 >    iptr p = 0;
7500 >    ++p;
7501 >  }
7502 >  { /* AIX XL C 1.02.0.0 rejects this saying
7503 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7504 >    struct s { int j; const int *ap[3]; };
7505 >    struct s *b; b->j = 5;
7506 >  }
7507 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7508 >    const int foo = 10;
7509 >  }
7510 > #endif
7511 >
7512 >  ;
7513 >  return 0;
7514 > }
7515 > _ACEOF
7516 > rm -f conftest.$ac_objext
7517 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7518 >  (eval $ac_compile) 2>conftest.er1
7519 >  ac_status=$?
7520 >  grep -v '^ *+' conftest.er1 >conftest.err
7521 >  rm -f conftest.er1
7522 >  cat conftest.err >&5
7523 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7524 >  (exit $ac_status); } &&
7525 >         { ac_try='test -z "$ac_c_werror_flag"
7526 >                         || test ! -s conftest.err'
7527 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7528 >  (eval $ac_try) 2>&5
7529 >  ac_status=$?
7530 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7531 >  (exit $ac_status); }; } &&
7532 >         { ac_try='test -s conftest.$ac_objext'
7533 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7534 >  (eval $ac_try) 2>&5
7535 >  ac_status=$?
7536 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7537 >  (exit $ac_status); }; }; then
7538 >  ac_cv_c_const=yes
7539 > else
7540 >  echo "$as_me: failed program was:" >&5
7541 > sed 's/^/| /' conftest.$ac_ext >&5
7542 >
7543 > ac_cv_c_const=no
7544 > fi
7545 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7546 > fi
7547 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7548 > echo "${ECHO_T}$ac_cv_c_const" >&6
7549 > if test $ac_cv_c_const = no; then
7550 >
7551 > cat >>confdefs.h <<\_ACEOF
7552 > #define const
7553 > _ACEOF
7554 >
7555 > fi
7556 >
7557 > echo "$as_me:$LINENO: checking for inline" >&5
7558 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
7559 > if test "${ac_cv_c_inline+set}" = set; then
7560 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7561 > else
7562 >  ac_cv_c_inline=no
7563 > for ac_kw in inline __inline__ __inline; do
7564 >  cat >conftest.$ac_ext <<_ACEOF
7565 > /* confdefs.h.  */
7566 > _ACEOF
7567 > cat confdefs.h >>conftest.$ac_ext
7568 > cat >>conftest.$ac_ext <<_ACEOF
7569 > /* end confdefs.h.  */
7570 > #ifndef __cplusplus
7571 > typedef int foo_t;
7572 > static $ac_kw foo_t static_foo () {return 0; }
7573 > $ac_kw foo_t foo () {return 0; }
7574 > #endif
7575 >
7576 > _ACEOF
7577 > rm -f conftest.$ac_objext
7578 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7579 >  (eval $ac_compile) 2>conftest.er1
7580 >  ac_status=$?
7581 >  grep -v '^ *+' conftest.er1 >conftest.err
7582 >  rm -f conftest.er1
7583 >  cat conftest.err >&5
7584 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7585 >  (exit $ac_status); } &&
7586 >         { ac_try='test -z "$ac_c_werror_flag"
7587 >                         || test ! -s conftest.err'
7588 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7589 >  (eval $ac_try) 2>&5
7590 >  ac_status=$?
7591 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7592 >  (exit $ac_status); }; } &&
7593 >         { ac_try='test -s conftest.$ac_objext'
7594 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7595 >  (eval $ac_try) 2>&5
7596 >  ac_status=$?
7597 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7598 >  (exit $ac_status); }; }; then
7599 >  ac_cv_c_inline=$ac_kw; break
7600 > else
7601 >  echo "$as_me: failed program was:" >&5
7602 > sed 's/^/| /' conftest.$ac_ext >&5
7603 >
7604 > fi
7605 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7606 > done
7607 >
7608 > fi
7609 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7610 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7611 >
7612 >
7613 > case $ac_cv_c_inline in
7614 >  inline | yes) ;;
7615 >  *)
7616 >    case $ac_cv_c_inline in
7617 >      no) ac_val=;;
7618 >      *) ac_val=$ac_cv_c_inline;;
7619 >    esac
7620 >    cat >>confdefs.h <<_ACEOF
7621 > #ifndef __cplusplus
7622 > #define inline $ac_val
7623 > #endif
7624 > _ACEOF
7625 >    ;;
7626 > esac
7627 >
7628 > echo "$as_me:$LINENO: checking for C/C++ restrict keyword" >&5
7629 > echo $ECHO_N "checking for C/C++ restrict keyword... $ECHO_C" >&6
7630 > if test "${ac_cv_c_restrict+set}" = set; then
7631 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7632 > else
7633 >  ac_cv_c_restrict=no
7634 >   # Try the official restrict keyword, then gcc's __restrict, and
7635 >   # the less common variants.
7636 >   for ac_kw in restrict __restrict __restrict__ _Restrict; do
7637 >     cat >conftest.$ac_ext <<_ACEOF
7638 > /* confdefs.h.  */
7639 > _ACEOF
7640 > cat confdefs.h >>conftest.$ac_ext
7641 > cat >>conftest.$ac_ext <<_ACEOF
7642 > /* end confdefs.h.  */
7643 > float * $ac_kw x;
7644 > _ACEOF
7645 > rm -f conftest.$ac_objext
7646 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7647 >  (eval $ac_compile) 2>conftest.er1
7648 >  ac_status=$?
7649 >  grep -v '^ *+' conftest.er1 >conftest.err
7650 >  rm -f conftest.er1
7651 >  cat conftest.err >&5
7652 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7653 >  (exit $ac_status); } &&
7654 >         { ac_try='test -z "$ac_c_werror_flag"
7655 >                         || test ! -s conftest.err'
7656 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7657 >  (eval $ac_try) 2>&5
7658 >  ac_status=$?
7659 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7660 >  (exit $ac_status); }; } &&
7661 >         { ac_try='test -s conftest.$ac_objext'
7662 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7663 >  (eval $ac_try) 2>&5
7664 >  ac_status=$?
7665 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7666 >  (exit $ac_status); }; }; then
7667 >  ac_cv_c_restrict=$ac_kw; break
7668 > else
7669 >  echo "$as_me: failed program was:" >&5
7670 > sed 's/^/| /' conftest.$ac_ext >&5
7671 >
7672 > fi
7673 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7674 >   done
7675 >
7676 > fi
7677 > echo "$as_me:$LINENO: result: $ac_cv_c_restrict" >&5
7678 > echo "${ECHO_T}$ac_cv_c_restrict" >&6
7679 > case $ac_cv_c_restrict in
7680 >   restrict) ;;
7681 >   no)
7682 > cat >>confdefs.h <<\_ACEOF
7683 > #define restrict
7684 > _ACEOF
7685 > ;;
7686 >   *)  cat >>confdefs.h <<_ACEOF
7687 > #define restrict $ac_cv_c_restrict
7688 > _ACEOF
7689 > ;;
7690 > esac
7691 >
7692 > echo "$as_me:$LINENO: checking for size_t" >&5
7693 > echo $ECHO_N "checking for size_t... $ECHO_C" >&6
7694 > if test "${ac_cv_type_size_t+set}" = set; then
7695 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7696 > else
7697 >  cat >conftest.$ac_ext <<_ACEOF
7698 > /* confdefs.h.  */
7699 > _ACEOF
7700 > cat confdefs.h >>conftest.$ac_ext
7701 > cat >>conftest.$ac_ext <<_ACEOF
7702 > /* end confdefs.h.  */
7703 > $ac_includes_default
7704 > #ifdef FC_DUMMY_MAIN
7705 > #ifndef FC_DUMMY_MAIN_EQ_F77
7706 > #  ifdef __cplusplus
7707 >     extern "C"
7708 > #  endif
7709 >   int FC_DUMMY_MAIN() { return 1; }
7710 > #endif
7711 > #endif
7712 > int
7713 > main ()
7714 > {
7715 > if ((size_t *) 0)
7716 >  return 0;
7717 > if (sizeof (size_t))
7718 >  return 0;
7719 >  ;
7720 >  return 0;
7721 > }
7722 > _ACEOF
7723 > rm -f conftest.$ac_objext
7724 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7725 >  (eval $ac_compile) 2>conftest.er1
7726 >  ac_status=$?
7727 >  grep -v '^ *+' conftest.er1 >conftest.err
7728 >  rm -f conftest.er1
7729 >  cat conftest.err >&5
7730 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7731 >  (exit $ac_status); } &&
7732 >         { ac_try='test -z "$ac_c_werror_flag"
7733 >                         || test ! -s conftest.err'
7734 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7735 >  (eval $ac_try) 2>&5
7736 >  ac_status=$?
7737 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7738 >  (exit $ac_status); }; } &&
7739 >         { ac_try='test -s conftest.$ac_objext'
7740 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7741 >  (eval $ac_try) 2>&5
7742 >  ac_status=$?
7743 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7744 >  (exit $ac_status); }; }; then
7745 >  ac_cv_type_size_t=yes
7746 > else
7747 >  echo "$as_me: failed program was:" >&5
7748 > sed 's/^/| /' conftest.$ac_ext >&5
7749 >
7750 > ac_cv_type_size_t=no
7751 > fi
7752 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7753 > fi
7754 > echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
7755 > echo "${ECHO_T}$ac_cv_type_size_t" >&6
7756 > if test $ac_cv_type_size_t = yes; then
7757 >  :
7758 > else
7759 >
7760 > cat >>confdefs.h <<_ACEOF
7761 > #define size_t unsigned
7762 > _ACEOF
7763 >
7764 > fi
7765 >
7766 > echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
7767 > echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
7768 > if test "${ac_cv_header_time+set}" = set; then
7769 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7770 > else
7771 >  cat >conftest.$ac_ext <<_ACEOF
7772 > /* confdefs.h.  */
7773 > _ACEOF
7774 > cat confdefs.h >>conftest.$ac_ext
7775 > cat >>conftest.$ac_ext <<_ACEOF
7776 > /* end confdefs.h.  */
7777 > #include <sys/types.h>
7778 > #include <sys/time.h>
7779 > #include <time.h>
7780 >
7781 > #ifdef FC_DUMMY_MAIN
7782 > #ifndef FC_DUMMY_MAIN_EQ_F77
7783 > #  ifdef __cplusplus
7784 >     extern "C"
7785 > #  endif
7786 >   int FC_DUMMY_MAIN() { return 1; }
7787 > #endif
7788 > #endif
7789 > int
7790 > main ()
7791 > {
7792 > if ((struct tm *) 0)
7793 > return 0;
7794 >  ;
7795 >  return 0;
7796 > }
7797 > _ACEOF
7798 > rm -f conftest.$ac_objext
7799 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7800 >  (eval $ac_compile) 2>conftest.er1
7801 >  ac_status=$?
7802 >  grep -v '^ *+' conftest.er1 >conftest.err
7803 >  rm -f conftest.er1
7804 >  cat conftest.err >&5
7805 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7806 >  (exit $ac_status); } &&
7807 >         { ac_try='test -z "$ac_c_werror_flag"
7808 >                         || test ! -s conftest.err'
7809 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7810 >  (eval $ac_try) 2>&5
7811 >  ac_status=$?
7812 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7813 >  (exit $ac_status); }; } &&
7814 >         { ac_try='test -s conftest.$ac_objext'
7815 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7816 >  (eval $ac_try) 2>&5
7817 >  ac_status=$?
7818 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7819 >  (exit $ac_status); }; }; then
7820 >  ac_cv_header_time=yes
7821 > else
7822 >  echo "$as_me: failed program was:" >&5
7823 > sed 's/^/| /' conftest.$ac_ext >&5
7824 >
7825 > ac_cv_header_time=no
7826 > fi
7827 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7828 > fi
7829 > echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
7830 > echo "${ECHO_T}$ac_cv_header_time" >&6
7831 > if test $ac_cv_header_time = yes; then
7832 >
7833 > cat >>confdefs.h <<\_ACEOF
7834 > #define TIME_WITH_SYS_TIME 1
7835 > _ACEOF
7836 >
7837 > fi
7838 >
7839 > echo "$as_me:$LINENO: checking for clock_t" >&5
7840 > echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
7841 > if test "${ac_cv_type_clock_t+set}" = set; then
7842 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7843 > else
7844 >  cat >conftest.$ac_ext <<_ACEOF
7845 > /* confdefs.h.  */
7846 > _ACEOF
7847 > cat confdefs.h >>conftest.$ac_ext
7848 > cat >>conftest.$ac_ext <<_ACEOF
7849 > /* end confdefs.h.  */
7850 > $ac_includes_default
7851 > #ifdef FC_DUMMY_MAIN
7852 > #ifndef FC_DUMMY_MAIN_EQ_F77
7853 > #  ifdef __cplusplus
7854 >     extern "C"
7855 > #  endif
7856 >   int FC_DUMMY_MAIN() { return 1; }
7857 > #endif
7858 > #endif
7859 > int
7860 > main ()
7861 > {
7862 > if ((clock_t *) 0)
7863 >  return 0;
7864 > if (sizeof (clock_t))
7865 >  return 0;
7866 >  ;
7867 >  return 0;
7868 > }
7869 > _ACEOF
7870 > rm -f conftest.$ac_objext
7871 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7872 >  (eval $ac_compile) 2>conftest.er1
7873 >  ac_status=$?
7874 >  grep -v '^ *+' conftest.er1 >conftest.err
7875 >  rm -f conftest.er1
7876 >  cat conftest.err >&5
7877 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7878 >  (exit $ac_status); } &&
7879 >         { ac_try='test -z "$ac_c_werror_flag"
7880 >                         || test ! -s conftest.err'
7881 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7882 >  (eval $ac_try) 2>&5
7883 >  ac_status=$?
7884 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7885 >  (exit $ac_status); }; } &&
7886 >         { ac_try='test -s conftest.$ac_objext'
7887 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7888 >  (eval $ac_try) 2>&5
7889 >  ac_status=$?
7890 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7891 >  (exit $ac_status); }; }; then
7892 >  ac_cv_type_clock_t=yes
7893 > else
7894 >  echo "$as_me: failed program was:" >&5
7895 > sed 's/^/| /' conftest.$ac_ext >&5
7896 >
7897 > ac_cv_type_clock_t=no
7898 > fi
7899 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7900 > fi
7901 > echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
7902 > echo "${ECHO_T}$ac_cv_type_clock_t" >&6
7903 > if test $ac_cv_type_clock_t = yes; then
7904 >
7905 > cat >>confdefs.h <<_ACEOF
7906 > #define HAVE_CLOCK_T 1
7907 > _ACEOF
7908 >
7909 >
7910 > fi
7911 >
7912 > echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
7913 > echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
7914 > if test "${ac_cv_c_const+set}" = set; then
7915 >  echo $ECHO_N "(cached) $ECHO_C" >&6
7916 > else
7917 >  cat >conftest.$ac_ext <<_ACEOF
7918 > /* confdefs.h.  */
7919 > _ACEOF
7920 > cat confdefs.h >>conftest.$ac_ext
7921 > cat >>conftest.$ac_ext <<_ACEOF
7922 > /* end confdefs.h.  */
7923 >
7924 > #ifdef FC_DUMMY_MAIN
7925 > #ifndef FC_DUMMY_MAIN_EQ_F77
7926 > #  ifdef __cplusplus
7927 >     extern "C"
7928 > #  endif
7929 >   int FC_DUMMY_MAIN() { return 1; }
7930 > #endif
7931 > #endif
7932 > int
7933 > main ()
7934 > {
7935 > /* FIXME: Include the comments suggested by Paul. */
7936 > #ifndef __cplusplus
7937 >  /* Ultrix mips cc rejects this.  */
7938 >  typedef int charset[2];
7939 >  const charset x;
7940 >  /* SunOS 4.1.1 cc rejects this.  */
7941 >  char const *const *ccp;
7942 >  char **p;
7943 >  /* NEC SVR4.0.2 mips cc rejects this.  */
7944 >  struct point {int x, y;};
7945 >  static struct point const zero = {0,0};
7946 >  /* AIX XL C 1.02.0.0 rejects this.
7947 >     It does not let you subtract one const X* pointer from another in
7948 >     an arm of an if-expression whose if-part is not a constant
7949 >     expression */
7950 >  const char *g = "string";
7951 >  ccp = &g + (g ? g-g : 0);
7952 >  /* HPUX 7.0 cc rejects these. */
7953 >  ++ccp;
7954 >  p = (char**) ccp;
7955 >  ccp = (char const *const *) p;
7956 >  { /* SCO 3.2v4 cc rejects this.  */
7957 >    char *t;
7958 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
7959 >
7960 >    *t++ = 0;
7961 >  }
7962 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7963 >    int x[] = {25, 17};
7964 >    const int *foo = &x[0];
7965 >    ++foo;
7966 >  }
7967 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7968 >    typedef const int *iptr;
7969 >    iptr p = 0;
7970 >    ++p;
7971 >  }
7972 >  { /* AIX XL C 1.02.0.0 rejects this saying
7973 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7974 >    struct s { int j; const int *ap[3]; };
7975 >    struct s *b; b->j = 5;
7976 >  }
7977 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7978 >    const int foo = 10;
7979 >  }
7980 > #endif
7981 >
7982 >  ;
7983 >  return 0;
7984 > }
7985 > _ACEOF
7986 > rm -f conftest.$ac_objext
7987 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7988 >  (eval $ac_compile) 2>conftest.er1
7989 >  ac_status=$?
7990 >  grep -v '^ *+' conftest.er1 >conftest.err
7991 >  rm -f conftest.er1
7992 >  cat conftest.err >&5
7993 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7994 >  (exit $ac_status); } &&
7995 >         { ac_try='test -z "$ac_c_werror_flag"
7996 >                         || test ! -s conftest.err'
7997 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7998 >  (eval $ac_try) 2>&5
7999 >  ac_status=$?
8000 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8001 >  (exit $ac_status); }; } &&
8002 >         { ac_try='test -s conftest.$ac_objext'
8003 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8004 >  (eval $ac_try) 2>&5
8005 >  ac_status=$?
8006 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8007 >  (exit $ac_status); }; }; then
8008 >  ac_cv_c_const=yes
8009 > else
8010 >  echo "$as_me: failed program was:" >&5
8011 > sed 's/^/| /' conftest.$ac_ext >&5
8012 >
8013 > ac_cv_c_const=no
8014 > fi
8015 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8016 > fi
8017 > echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
8018 > echo "${ECHO_T}$ac_cv_c_const" >&6
8019 > if test $ac_cv_c_const = no; then
8020 >
8021 > cat >>confdefs.h <<\_ACEOF
8022 > #define const
8023 > _ACEOF
8024 >
8025 > fi
8026 >
8027 > echo "$as_me:$LINENO: checking for inline" >&5
8028 > echo $ECHO_N "checking for inline... $ECHO_C" >&6
8029 > if test "${ac_cv_c_inline+set}" = set; then
8030 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8031 > else
8032 >  ac_cv_c_inline=no
8033 > for ac_kw in inline __inline__ __inline; do
8034 >  cat >conftest.$ac_ext <<_ACEOF
8035 > /* confdefs.h.  */
8036 > _ACEOF
8037 > cat confdefs.h >>conftest.$ac_ext
8038 > cat >>conftest.$ac_ext <<_ACEOF
8039 > /* end confdefs.h.  */
8040 > #ifndef __cplusplus
8041 > typedef int foo_t;
8042 > static $ac_kw foo_t static_foo () {return 0; }
8043 > $ac_kw foo_t foo () {return 0; }
8044 > #endif
8045 >
8046 > _ACEOF
8047 > rm -f conftest.$ac_objext
8048 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8049 >  (eval $ac_compile) 2>conftest.er1
8050 >  ac_status=$?
8051 >  grep -v '^ *+' conftest.er1 >conftest.err
8052 >  rm -f conftest.er1
8053 >  cat conftest.err >&5
8054 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8055 >  (exit $ac_status); } &&
8056 >         { ac_try='test -z "$ac_c_werror_flag"
8057 >                         || test ! -s conftest.err'
8058 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8059 >  (eval $ac_try) 2>&5
8060 >  ac_status=$?
8061 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8062 >  (exit $ac_status); }; } &&
8063 >         { ac_try='test -s conftest.$ac_objext'
8064 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8065 >  (eval $ac_try) 2>&5
8066 >  ac_status=$?
8067 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8068 >  (exit $ac_status); }; }; then
8069 >  ac_cv_c_inline=$ac_kw; break
8070 > else
8071 >  echo "$as_me: failed program was:" >&5
8072 > sed 's/^/| /' conftest.$ac_ext >&5
8073 >
8074 > fi
8075 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8076 > done
8077 >
8078 > fi
8079 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
8080 > echo "${ECHO_T}$ac_cv_c_inline" >&6
8081 >
8082 >
8083 > case $ac_cv_c_inline in
8084 >  inline | yes) ;;
8085 >  *)
8086 >    case $ac_cv_c_inline in
8087 >      no) ac_val=;;
8088 >      *) ac_val=$ac_cv_c_inline;;
8089 >    esac
8090 >    cat >>confdefs.h <<_ACEOF
8091 > #ifndef __cplusplus
8092 > #define inline $ac_val
8093 > #endif
8094 > _ACEOF
8095 >    ;;
8096 > esac
8097 >
8098 >
8099 > # Checks for library functions.
8100 >
8101 > for ac_header in stdlib.h
8102 > do
8103 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8104 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8105 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8106 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8107 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8108 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8109 > fi
8110 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8111 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8112 > else
8113 >  # Is the header compilable?
8114 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8115 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8116 > cat >conftest.$ac_ext <<_ACEOF
8117 > /* confdefs.h.  */
8118 > _ACEOF
8119 > cat confdefs.h >>conftest.$ac_ext
8120 > cat >>conftest.$ac_ext <<_ACEOF
8121 > /* end confdefs.h.  */
8122 > $ac_includes_default
8123 > #include <$ac_header>
8124 > _ACEOF
8125 > rm -f conftest.$ac_objext
8126 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8127 >  (eval $ac_compile) 2>conftest.er1
8128 >  ac_status=$?
8129 >  grep -v '^ *+' conftest.er1 >conftest.err
8130 >  rm -f conftest.er1
8131 >  cat conftest.err >&5
8132 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8133 >  (exit $ac_status); } &&
8134 >         { ac_try='test -z "$ac_c_werror_flag"
8135 >                         || test ! -s conftest.err'
8136 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8137 >  (eval $ac_try) 2>&5
8138 >  ac_status=$?
8139 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8140 >  (exit $ac_status); }; } &&
8141 >         { ac_try='test -s conftest.$ac_objext'
8142 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8143 >  (eval $ac_try) 2>&5
8144 >  ac_status=$?
8145 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8146 >  (exit $ac_status); }; }; then
8147 >  ac_header_compiler=yes
8148 > else
8149 >  echo "$as_me: failed program was:" >&5
8150 > sed 's/^/| /' conftest.$ac_ext >&5
8151 >
8152 > ac_header_compiler=no
8153 > fi
8154 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8155 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8156 > echo "${ECHO_T}$ac_header_compiler" >&6
8157 >
8158 > # Is the header present?
8159 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8160 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8161 > cat >conftest.$ac_ext <<_ACEOF
8162 > /* confdefs.h.  */
8163 > _ACEOF
8164 > cat confdefs.h >>conftest.$ac_ext
8165 > cat >>conftest.$ac_ext <<_ACEOF
8166 > /* end confdefs.h.  */
8167 > #include <$ac_header>
8168 > _ACEOF
8169 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8170 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8171 >  ac_status=$?
8172 >  grep -v '^ *+' conftest.er1 >conftest.err
8173 >  rm -f conftest.er1
8174 >  cat conftest.err >&5
8175 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8176 >  (exit $ac_status); } >/dev/null; then
8177 >  if test -s conftest.err; then
8178 >    ac_cpp_err=$ac_c_preproc_warn_flag
8179 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8180 >  else
8181 >    ac_cpp_err=
8182 >  fi
8183 > else
8184 >  ac_cpp_err=yes
8185 > fi
8186 > if test -z "$ac_cpp_err"; then
8187 >  ac_header_preproc=yes
8188 > else
8189 >  echo "$as_me: failed program was:" >&5
8190 > sed 's/^/| /' conftest.$ac_ext >&5
8191 >
8192 >  ac_header_preproc=no
8193 > fi
8194 > rm -f conftest.err conftest.$ac_ext
8195 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8196 > echo "${ECHO_T}$ac_header_preproc" >&6
8197 >
8198 > # So?  What about this header?
8199 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8200 >  yes:no: )
8201 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8202 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8203 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8204 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8205 >    ac_header_preproc=yes
8206 >    ;;
8207 >  no:yes:* )
8208 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8209 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8210 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8211 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8212 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8213 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8214 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8215 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8216 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8217 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8218 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8219 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8220 >    (
8221 >      cat <<\_ASBOX
8222 > ## ------------------------------ ##
8223 > ## Report this to gezelter@nd.edu ##
8224 > ## ------------------------------ ##
8225 > _ASBOX
8226 >    ) |
8227 >      sed "s/^/$as_me: WARNING:     /" >&2
8228 >    ;;
8229 > esac
8230 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8231 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8232 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8233 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8234 > else
8235 >  eval "$as_ac_Header=\$ac_header_preproc"
8236 > fi
8237 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8238 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8239 >
8240 > fi
8241 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8242 >  cat >>confdefs.h <<_ACEOF
8243 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8244 > _ACEOF
8245 >
8246 > fi
8247 >
8248 > done
8249 >
8250 > echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
8251 > echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6
8252 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
8253 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8254 > else
8255 >  if test "$cross_compiling" = yes; then
8256 >  ac_cv_func_malloc_0_nonnull=no
8257 > else
8258 >  cat >conftest.$ac_ext <<_ACEOF
8259 > /* confdefs.h.  */
8260 > _ACEOF
8261 > cat confdefs.h >>conftest.$ac_ext
8262 > cat >>conftest.$ac_ext <<_ACEOF
8263 > /* end confdefs.h.  */
8264 > #if STDC_HEADERS || HAVE_STDLIB_H
8265 > # include <stdlib.h>
8266 > #else
8267 > char *malloc ();
8268 > #endif
8269 >
8270 > #ifdef FC_DUMMY_MAIN
8271 > #ifndef FC_DUMMY_MAIN_EQ_F77
8272 > #  ifdef __cplusplus
8273 >     extern "C"
8274 > #  endif
8275 >   int FC_DUMMY_MAIN() { return 1; }
8276 > #endif
8277 > #endif
8278 > int
8279 > main ()
8280 > {
8281 > exit (malloc (0) ? 0 : 1);
8282 >  ;
8283 >  return 0;
8284 > }
8285 > _ACEOF
8286 > rm -f conftest$ac_exeext
8287 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8288 >  (eval $ac_link) 2>&5
8289 >  ac_status=$?
8290 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8291 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8292 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8293 >  (eval $ac_try) 2>&5
8294 >  ac_status=$?
8295 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8296 >  (exit $ac_status); }; }; then
8297 >  ac_cv_func_malloc_0_nonnull=yes
8298 > else
8299 >  echo "$as_me: program exited with status $ac_status" >&5
8300 > echo "$as_me: failed program was:" >&5
8301 > sed 's/^/| /' conftest.$ac_ext >&5
8302 >
8303 > ( exit $ac_status )
8304 > ac_cv_func_malloc_0_nonnull=no
8305 > fi
8306 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8307 > fi
8308 > fi
8309 > echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
8310 > echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6
8311 > if test $ac_cv_func_malloc_0_nonnull = yes; then
8312 >
8313 > cat >>confdefs.h <<\_ACEOF
8314 > #define HAVE_MALLOC 1
8315 > _ACEOF
8316 >
8317 > else
8318 >  cat >>confdefs.h <<\_ACEOF
8319 > #define HAVE_MALLOC 0
8320 > _ACEOF
8321 >
8322 >   case $LIBOBJS in
8323 >    "malloc.$ac_objext"   | \
8324 >  *" malloc.$ac_objext"   | \
8325 >    "malloc.$ac_objext "* | \
8326 >  *" malloc.$ac_objext "* ) ;;
8327 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext" ;;
8328 > esac
8329 >
8330 >
8331 > cat >>confdefs.h <<\_ACEOF
8332 > #define malloc rpl_malloc
8333 > _ACEOF
8334 >
8335 > fi
8336 >
8337 >
8338 >
8339 > echo "$as_me:$LINENO: checking for working memcmp" >&5
8340 > echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6
8341 > if test "${ac_cv_func_memcmp_working+set}" = set; then
8342 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8343 > else
8344 >  if test "$cross_compiling" = yes; then
8345 >  ac_cv_func_memcmp_working=no
8346 > else
8347 >  cat >conftest.$ac_ext <<_ACEOF
8348 > /* confdefs.h.  */
8349 > _ACEOF
8350 > cat confdefs.h >>conftest.$ac_ext
8351 > cat >>conftest.$ac_ext <<_ACEOF
8352 > /* end confdefs.h.  */
8353 > $ac_includes_default
8354 > #ifdef FC_DUMMY_MAIN
8355 > #ifndef FC_DUMMY_MAIN_EQ_F77
8356 > #  ifdef __cplusplus
8357 >     extern "C"
8358 > #  endif
8359 >   int FC_DUMMY_MAIN() { return 1; }
8360 > #endif
8361 > #endif
8362 > int
8363 > main ()
8364 > {
8365 >
8366 >  /* Some versions of memcmp are not 8-bit clean.  */
8367 >  char c0 = 0x40, c1 = 0x80, c2 = 0x81;
8368 >  if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)
8369 >    exit (1);
8370 >
8371 >  /* The Next x86 OpenStep bug shows up only when comparing 16 bytes
8372 >     or more and with at least one buffer not starting on a 4-byte boundary.
8373 >     William Lewis provided this test program.   */
8374 >  {
8375 >    char foo[21];
8376 >    char bar[21];
8377 >    int i;
8378 >    for (i = 0; i < 4; i++)
8379 >      {
8380 >        char *a = foo + i;
8381 >        char *b = bar + i;
8382 >        strcpy (a, "--------01111111");
8383 >        strcpy (b, "--------10000000");
8384 >        if (memcmp (a, b, 16) >= 0)
8385 >          exit (1);
8386 >      }
8387 >    exit (0);
8388 >  }
8389 >
8390 >  ;
8391 >  return 0;
8392 > }
8393 > _ACEOF
8394 > rm -f conftest$ac_exeext
8395 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8396 >  (eval $ac_link) 2>&5
8397 >  ac_status=$?
8398 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8399 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8400 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8401 >  (eval $ac_try) 2>&5
8402 >  ac_status=$?
8403 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8404 >  (exit $ac_status); }; }; then
8405 >  ac_cv_func_memcmp_working=yes
8406 > else
8407 >  echo "$as_me: program exited with status $ac_status" >&5
8408 > echo "$as_me: failed program was:" >&5
8409 > sed 's/^/| /' conftest.$ac_ext >&5
8410 >
8411 > ( exit $ac_status )
8412 > ac_cv_func_memcmp_working=no
8413 > fi
8414 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8415 > fi
8416 > fi
8417 > echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5
8418 > echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6
8419 > test $ac_cv_func_memcmp_working = no && case $LIBOBJS in
8420 >    "memcmp.$ac_objext"   | \
8421 >  *" memcmp.$ac_objext"   | \
8422 >    "memcmp.$ac_objext "* | \
8423 >  *" memcmp.$ac_objext "* ) ;;
8424 >  *) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;
8425 > esac
8426 >
8427 >
8428 >
8429 > for ac_header in stdlib.h
8430 > do
8431 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8432 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8433 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8434 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8435 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8436 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8437 > fi
8438 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8439 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8440 > else
8441 >  # Is the header compilable?
8442 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8443 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8444 > cat >conftest.$ac_ext <<_ACEOF
8445 > /* confdefs.h.  */
8446 > _ACEOF
8447 > cat confdefs.h >>conftest.$ac_ext
8448 > cat >>conftest.$ac_ext <<_ACEOF
8449 > /* end confdefs.h.  */
8450 > $ac_includes_default
8451 > #include <$ac_header>
8452 > _ACEOF
8453 > rm -f conftest.$ac_objext
8454 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8455 >  (eval $ac_compile) 2>conftest.er1
8456    ac_status=$?
8457    grep -v '^ *+' conftest.er1 >conftest.err
8458    rm -f conftest.er1
8459    cat conftest.err >&5
8460    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8461    (exit $ac_status); } &&
8462 <         { ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
8462 >         { ac_try='test -z "$ac_c_werror_flag"
8463 >                         || test ! -s conftest.err'
8464    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8465    (eval $ac_try) 2>&5
8466    ac_status=$?
8467    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8468    (exit $ac_status); }; } &&
8469 <         { ac_try='test -s conftest$ac_exeext'
8469 >         { ac_try='test -s conftest.$ac_objext'
8470    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8471    (eval $ac_try) 2>&5
8472    ac_status=$?
8473    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8474    (exit $ac_status); }; }; then
8475 <  ac_cv_lib_m_asin=yes
8475 >  ac_header_compiler=yes
8476   else
8477    echo "$as_me: failed program was:" >&5
8478   sed 's/^/| /' conftest.$ac_ext >&5
8479  
8480 < ac_cv_lib_m_asin=no
8480 > ac_header_compiler=no
8481   fi
8482 < rm -f conftest.err conftest.$ac_objext \
8483 <      conftest$ac_exeext conftest.$ac_ext
8484 < LIBS=$ac_check_lib_save_LIBS
4517 < fi
4518 < echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
4519 < echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
4520 < if test $ac_cv_lib_m_asin = yes; then
4521 <  cat >>confdefs.h <<_ACEOF
4522 < #define HAVE_LIBM 1
4523 < _ACEOF
8482 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8483 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8484 > echo "${ECHO_T}$ac_header_compiler" >&6
8485  
8486 <  LIBS="-lm $LIBS"
8487 <
8488 < else
8489 <  exit
4529 < fi
4530 <
4531 <
4532 < ac_ext=c
4533 < ac_cpp='$CPP $CPPFLAGS'
4534 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4535 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4536 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4537 <
4538 < ac_ext=c
4539 < ac_cpp='$CPP $CPPFLAGS'
4540 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4541 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4542 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4543 < echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4544 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
4545 < # On Suns, sometimes $CPP names a directory.
4546 < if test -n "$CPP" && test -d "$CPP"; then
4547 <  CPP=
4548 < fi
4549 < if test -z "$CPP"; then
4550 <  if test "${ac_cv_prog_CPP+set}" = set; then
4551 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4552 < else
4553 <      # Double quotes because CPP needs to be expanded
4554 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
4555 <    do
4556 <      ac_preproc_ok=false
4557 < for ac_c_preproc_warn_flag in '' yes
4558 < do
4559 <  # Use a header file that comes with gcc, so configuring glibc
4560 <  # with a fresh cross-compiler works.
4561 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4562 <  # <limits.h> exists even on freestanding compilers.
4563 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4564 <  # not just through cpp. "Syntax error" is here to catch this case.
4565 <  cat >conftest.$ac_ext <<_ACEOF
8486 > # Is the header present?
8487 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8488 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8489 > cat >conftest.$ac_ext <<_ACEOF
8490   /* confdefs.h.  */
8491   _ACEOF
8492   cat confdefs.h >>conftest.$ac_ext
8493   cat >>conftest.$ac_ext <<_ACEOF
8494   /* end confdefs.h.  */
8495 < #ifdef __STDC__
4572 < # include <limits.h>
4573 < #else
4574 < # include <assert.h>
4575 < #endif
4576 <                     Syntax error
8495 > #include <$ac_header>
8496   _ACEOF
8497   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8498    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 4593 | Line 8512 | if test -z "$ac_cpp_err"; then
8512    ac_cpp_err=yes
8513   fi
8514   if test -z "$ac_cpp_err"; then
8515 <  :
8515 >  ac_header_preproc=yes
8516   else
8517    echo "$as_me: failed program was:" >&5
8518   sed 's/^/| /' conftest.$ac_ext >&5
8519  
8520 <  # Broken: fails on valid input.
4602 < continue
8520 >  ac_header_preproc=no
8521   fi
8522   rm -f conftest.err conftest.$ac_ext
8523 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8524 + echo "${ECHO_T}$ac_header_preproc" >&6
8525  
8526 <  # OK, works on sane cases.  Now check whether non-existent headers
8527 <  # can be detected and how.
8526 > # So?  What about this header?
8527 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8528 >  yes:no: )
8529 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8530 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8531 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8532 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8533 >    ac_header_preproc=yes
8534 >    ;;
8535 >  no:yes:* )
8536 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8537 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8538 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8539 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8540 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8541 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8542 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8543 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8544 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8545 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8546 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8547 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8548 >    (
8549 >      cat <<\_ASBOX
8550 > ## ------------------------------ ##
8551 > ## Report this to gezelter@nd.edu ##
8552 > ## ------------------------------ ##
8553 > _ASBOX
8554 >    ) |
8555 >      sed "s/^/$as_me: WARNING:     /" >&2
8556 >    ;;
8557 > esac
8558 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8559 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8560 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8561 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8562 > else
8563 >  eval "$as_ac_Header=\$ac_header_preproc"
8564 > fi
8565 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8566 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8567 >
8568 > fi
8569 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8570 >  cat >>confdefs.h <<_ACEOF
8571 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8572 > _ACEOF
8573 >
8574 > fi
8575 >
8576 > done
8577 >
8578 > echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
8579 > echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6
8580 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
8581 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8582 > else
8583 >  if test "$cross_compiling" = yes; then
8584 >  ac_cv_func_realloc_0_nonnull=no
8585 > else
8586    cat >conftest.$ac_ext <<_ACEOF
8587   /* confdefs.h.  */
8588   _ACEOF
8589   cat confdefs.h >>conftest.$ac_ext
8590   cat >>conftest.$ac_ext <<_ACEOF
8591   /* end confdefs.h.  */
8592 < #include <ac_nonexistent.h>
8592 > #if STDC_HEADERS || HAVE_STDLIB_H
8593 > # include <stdlib.h>
8594 > #else
8595 > char *realloc ();
8596 > #endif
8597 >
8598 > #ifdef FC_DUMMY_MAIN
8599 > #ifndef FC_DUMMY_MAIN_EQ_F77
8600 > #  ifdef __cplusplus
8601 >     extern "C"
8602 > #  endif
8603 >   int FC_DUMMY_MAIN() { return 1; }
8604 > #endif
8605 > #endif
8606 > int
8607 > main ()
8608 > {
8609 > exit (realloc (0, 0) ? 0 : 1);
8610 >  ;
8611 >  return 0;
8612 > }
8613   _ACEOF
8614 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8615 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8614 > rm -f conftest$ac_exeext
8615 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8616 >  (eval $ac_link) 2>&5
8617    ac_status=$?
4619 –  grep -v '^ *+' conftest.er1 >conftest.err
4620 –  rm -f conftest.er1
4621 –  cat conftest.err >&5
8618    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8619 <  (exit $ac_status); } >/dev/null; then
8620 <  if test -s conftest.err; then
8621 <    ac_cpp_err=$ac_c_preproc_warn_flag
8622 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8623 <  else
8624 <    ac_cpp_err=
8625 <  fi
8619 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
8620 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8621 >  (eval $ac_try) 2>&5
8622 >  ac_status=$?
8623 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8624 >  (exit $ac_status); }; }; then
8625 >  ac_cv_func_realloc_0_nonnull=yes
8626   else
8627 <  ac_cpp_err=yes
8628 < fi
4633 < if test -z "$ac_cpp_err"; then
4634 <  # Broken: success on invalid input.
4635 < continue
4636 < else
4637 <  echo "$as_me: failed program was:" >&5
8627 >  echo "$as_me: program exited with status $ac_status" >&5
8628 > echo "$as_me: failed program was:" >&5
8629   sed 's/^/| /' conftest.$ac_ext >&5
8630  
8631 <  # Passes both tests.
8632 < ac_preproc_ok=:
4642 < break
8631 > ( exit $ac_status )
8632 > ac_cv_func_realloc_0_nonnull=no
8633   fi
8634 < rm -f conftest.err conftest.$ac_ext
4645 <
4646 < done
4647 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4648 < rm -f conftest.err conftest.$ac_ext
4649 < if $ac_preproc_ok; then
4650 <  break
8634 > rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8635   fi
8636 + fi
8637 + echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
8638 + echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6
8639 + if test $ac_cv_func_realloc_0_nonnull = yes; then
8640  
8641 <    done
8642 <    ac_cv_prog_CPP=$CPP
8641 > cat >>confdefs.h <<\_ACEOF
8642 > #define HAVE_REALLOC 1
8643 > _ACEOF
8644  
4656 – fi
4657 –  CPP=$ac_cv_prog_CPP
8645   else
8646 <  ac_cv_prog_CPP=$CPP
8646 >  cat >>confdefs.h <<\_ACEOF
8647 > #define HAVE_REALLOC 0
8648 > _ACEOF
8649 >
8650 >   case $LIBOBJS in
8651 >    "realloc.$ac_objext"   | \
8652 >  *" realloc.$ac_objext"   | \
8653 >    "realloc.$ac_objext "* | \
8654 >  *" realloc.$ac_objext "* ) ;;
8655 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext" ;;
8656 > esac
8657 >
8658 >
8659 > cat >>confdefs.h <<\_ACEOF
8660 > #define realloc rpl_realloc
8661 > _ACEOF
8662 >
8663   fi
8664 < echo "$as_me:$LINENO: result: $CPP" >&5
8665 < echo "${ECHO_T}$CPP" >&6
8666 < ac_preproc_ok=false
8667 < for ac_c_preproc_warn_flag in '' yes
8664 >
8665 >
8666 >
8667 >
8668 >
8669 > for ac_header in sys/select.h sys/socket.h
8670   do
8671 <  # Use a header file that comes with gcc, so configuring glibc
8672 <  # with a fresh cross-compiler works.
8673 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8674 <  # <limits.h> exists even on freestanding compilers.
8675 <  # On the NeXT, cc -E runs the code through the compiler's parser,
8676 <  # not just through cpp. "Syntax error" is here to catch this case.
8677 <  cat >conftest.$ac_ext <<_ACEOF
8671 > as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
8672 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8673 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
8674 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8675 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8676 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8677 > fi
8678 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8679 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8680 > else
8681 >  # Is the header compilable?
8682 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
8683 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
8684 > cat >conftest.$ac_ext <<_ACEOF
8685   /* confdefs.h.  */
8686   _ACEOF
8687   cat confdefs.h >>conftest.$ac_ext
8688   cat >>conftest.$ac_ext <<_ACEOF
8689   /* end confdefs.h.  */
8690 < #ifdef __STDC__
8691 < # include <limits.h>
4680 < #else
4681 < # include <assert.h>
4682 < #endif
4683 <                     Syntax error
8690 > $ac_includes_default
8691 > #include <$ac_header>
8692   _ACEOF
8693 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8694 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8693 > rm -f conftest.$ac_objext
8694 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8695 >  (eval $ac_compile) 2>conftest.er1
8696    ac_status=$?
8697    grep -v '^ *+' conftest.er1 >conftest.err
8698    rm -f conftest.er1
8699    cat conftest.err >&5
8700    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8701 <  (exit $ac_status); } >/dev/null; then
8702 <  if test -s conftest.err; then
8703 <    ac_cpp_err=$ac_c_preproc_warn_flag
8704 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8705 <  else
8706 <    ac_cpp_err=
8707 <  fi
8701 >  (exit $ac_status); } &&
8702 >         { ac_try='test -z "$ac_c_werror_flag"
8703 >                         || test ! -s conftest.err'
8704 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8705 >  (eval $ac_try) 2>&5
8706 >  ac_status=$?
8707 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8708 >  (exit $ac_status); }; } &&
8709 >         { ac_try='test -s conftest.$ac_objext'
8710 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8711 >  (eval $ac_try) 2>&5
8712 >  ac_status=$?
8713 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8714 >  (exit $ac_status); }; }; then
8715 >  ac_header_compiler=yes
8716   else
4700 –  ac_cpp_err=yes
4701 – fi
4702 – if test -z "$ac_cpp_err"; then
4703 –  :
4704 – else
8717    echo "$as_me: failed program was:" >&5
8718   sed 's/^/| /' conftest.$ac_ext >&5
8719  
8720 <  # Broken: fails on valid input.
4709 < continue
8720 > ac_header_compiler=no
8721   fi
8722 < rm -f conftest.err conftest.$ac_ext
8722 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8723 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8724 > echo "${ECHO_T}$ac_header_compiler" >&6
8725  
8726 <  # OK, works on sane cases.  Now check whether non-existent headers
8727 <  # can be detected and how.
8728 <  cat >conftest.$ac_ext <<_ACEOF
8726 > # Is the header present?
8727 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
8728 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
8729 > cat >conftest.$ac_ext <<_ACEOF
8730   /* confdefs.h.  */
8731   _ACEOF
8732   cat confdefs.h >>conftest.$ac_ext
8733   cat >>conftest.$ac_ext <<_ACEOF
8734   /* end confdefs.h.  */
8735 < #include <ac_nonexistent.h>
8735 > #include <$ac_header>
8736   _ACEOF
8737   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8738    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 4738 | Line 8752 | if test -z "$ac_cpp_err"; then
8752    ac_cpp_err=yes
8753   fi
8754   if test -z "$ac_cpp_err"; then
8755 <  # Broken: success on invalid input.
4742 < continue
8755 >  ac_header_preproc=yes
8756   else
8757    echo "$as_me: failed program was:" >&5
8758   sed 's/^/| /' conftest.$ac_ext >&5
8759  
8760 <  # Passes both tests.
4748 < ac_preproc_ok=:
4749 < break
8760 >  ac_header_preproc=no
8761   fi
8762   rm -f conftest.err conftest.$ac_ext
8763 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8764 + echo "${ECHO_T}$ac_header_preproc" >&6
8765  
8766 < done
8767 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
8768 < rm -f conftest.err conftest.$ac_ext
8769 < if $ac_preproc_ok; then
8770 <  :
8766 > # So?  What about this header?
8767 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8768 >  yes:no: )
8769 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
8770 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
8771 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
8772 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
8773 >    ac_header_preproc=yes
8774 >    ;;
8775 >  no:yes:* )
8776 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
8777 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
8778 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
8779 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
8780 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
8781 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
8782 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
8783 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
8784 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
8785 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
8786 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
8787 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
8788 >    (
8789 >      cat <<\_ASBOX
8790 > ## ------------------------------ ##
8791 > ## Report this to gezelter@nd.edu ##
8792 > ## ------------------------------ ##
8793 > _ASBOX
8794 >    ) |
8795 >      sed "s/^/$as_me: WARNING:     /" >&2
8796 >    ;;
8797 > esac
8798 > echo "$as_me:$LINENO: checking for $ac_header" >&5
8799 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
8800 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
8801 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8802   else
8803 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4760 < See \`config.log' for more details." >&5
4761 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4762 < See \`config.log' for more details." >&2;}
4763 <   { (exit 1); exit 1; }; }
8803 >  eval "$as_ac_Header=\$ac_header_preproc"
8804   fi
8805 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
8806 + echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
8807  
8808 < ac_ext=c
8809 < ac_cpp='$CPP $CPPFLAGS'
8810 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8811 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8812 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8808 > fi
8809 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
8810 >  cat >>confdefs.h <<_ACEOF
8811 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
8812 > _ACEOF
8813  
4772 –
4773 – echo "$as_me:$LINENO: checking for egrep" >&5
4774 – echo $ECHO_N "checking for egrep... $ECHO_C" >&6
4775 – if test "${ac_cv_prog_egrep+set}" = set; then
4776 –  echo $ECHO_N "(cached) $ECHO_C" >&6
4777 – else
4778 –  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
4779 –    then ac_cv_prog_egrep='grep -E'
4780 –    else ac_cv_prog_egrep='egrep'
4781 –    fi
8814   fi
4783 – echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
4784 – echo "${ECHO_T}$ac_cv_prog_egrep" >&6
4785 – EGREP=$ac_cv_prog_egrep
8815  
8816 + done
8817  
8818 < echo "$as_me:$LINENO: checking for ANSI C header files" >&5
8819 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
8820 < if test "${ac_cv_header_stdc+set}" = set; then
8818 > echo "$as_me:$LINENO: checking types of arguments for select" >&5
8819 > echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6
8820 > if test "${ac_cv_func_select_args+set}" = set; then
8821    echo $ECHO_N "(cached) $ECHO_C" >&6
8822   else
8823 <  cat >conftest.$ac_ext <<_ACEOF
8823 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
8824 > for ac_arg1 in 'int' 'size_t' 'unsigned long' 'unsigned'; do
8825 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
8826 >   cat >conftest.$ac_ext <<_ACEOF
8827   /* confdefs.h.  */
8828   _ACEOF
8829   cat confdefs.h >>conftest.$ac_ext
8830   cat >>conftest.$ac_ext <<_ACEOF
8831   /* end confdefs.h.  */
8832 < #include <stdlib.h>
8833 < #include <stdarg.h>
8834 < #include <string.h>
8835 < #include <float.h>
8832 > $ac_includes_default
8833 > #if HAVE_SYS_SELECT_H
8834 > # include <sys/select.h>
8835 > #endif
8836 > #if HAVE_SYS_SOCKET_H
8837 > # include <sys/socket.h>
8838 > #endif
8839  
8840 + #ifdef FC_DUMMY_MAIN
8841 + #ifndef FC_DUMMY_MAIN_EQ_F77
8842 + #  ifdef __cplusplus
8843 +     extern "C"
8844 + #  endif
8845 +   int FC_DUMMY_MAIN() { return 1; }
8846 + #endif
8847 + #endif
8848   int
8849   main ()
8850   {
8851 <
8851 > extern int select ($ac_arg1,
8852 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
8853 >                                            $ac_arg5);
8854    ;
8855    return 0;
8856   }
# Line 4818 | Line 8864 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8864    cat conftest.err >&5
8865    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8866    (exit $ac_status); } &&
8867 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8867 >         { ac_try='test -z "$ac_c_werror_flag"
8868 >                         || test ! -s conftest.err'
8869    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8870    (eval $ac_try) 2>&5
8871    ac_status=$?
# Line 4830 | Line 8877 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8877    ac_status=$?
8878    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8879    (exit $ac_status); }; }; then
8880 <  ac_cv_header_stdc=yes
8880 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
8881   else
8882    echo "$as_me: failed program was:" >&5
8883   sed 's/^/| /' conftest.$ac_ext >&5
8884  
4838 – ac_cv_header_stdc=no
8885   fi
8886   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8887 +  done
8888 + done
8889 + done
8890 + # Provide a safe default value.
8891 + : ${ac_cv_func_select_args='int,int *,struct timeval *'}
8892  
8893 < if test $ac_cv_header_stdc = yes; then
8894 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
8893 > fi
8894 > echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
8895 > echo "${ECHO_T}$ac_cv_func_select_args" >&6
8896 > ac_save_IFS=$IFS; IFS=','
8897 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
8898 > IFS=$ac_save_IFS
8899 > shift
8900 >
8901 > cat >>confdefs.h <<_ACEOF
8902 > #define SELECT_TYPE_ARG1 $1
8903 > _ACEOF
8904 >
8905 >
8906 > cat >>confdefs.h <<_ACEOF
8907 > #define SELECT_TYPE_ARG234 ($2)
8908 > _ACEOF
8909 >
8910 >
8911 > cat >>confdefs.h <<_ACEOF
8912 > #define SELECT_TYPE_ARG5 ($3)
8913 > _ACEOF
8914 >
8915 > rm -f conftest*
8916 >
8917 >
8918 > for ac_func in strftime
8919 > do
8920 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
8921 > echo "$as_me:$LINENO: checking for $ac_func" >&5
8922 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8923 > if eval "test \"\${$as_ac_var+set}\" = set"; then
8924 >  echo $ECHO_N "(cached) $ECHO_C" >&6
8925 > else
8926    cat >conftest.$ac_ext <<_ACEOF
8927   /* confdefs.h.  */
8928   _ACEOF
8929   cat confdefs.h >>conftest.$ac_ext
8930   cat >>conftest.$ac_ext <<_ACEOF
8931   /* end confdefs.h.  */
8932 < #include <string.h>
8932 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8933 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8934 > #define $ac_func innocuous_$ac_func
8935  
8936 + /* System header to define __stub macros and hopefully few prototypes,
8937 +    which can conflict with char $ac_func (); below.
8938 +    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
8939 +    <limits.h> exists even on freestanding compilers.  */
8940 +
8941 + #ifdef __STDC__
8942 + # include <limits.h>
8943 + #else
8944 + # include <assert.h>
8945 + #endif
8946 +
8947 + #undef $ac_func
8948 +
8949 + /* Override any gcc2 internal prototype to avoid an error.  */
8950 + #ifdef __cplusplus
8951 + extern "C"
8952 + {
8953 + #endif
8954 + /* We use char because int might match the return type of a gcc2
8955 +   builtin and then its argument prototype would still apply.  */
8956 + char $ac_func ();
8957 + /* The GNU C library defines this for functions which it implements
8958 +    to always fail with ENOSYS.  Some functions are actually named
8959 +    something starting with __ and the normal name is an alias.  */
8960 + #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8961 + choke me
8962 + #else
8963 + char (*f) () = $ac_func;
8964 + #endif
8965 + #ifdef __cplusplus
8966 + }
8967 + #endif
8968 +
8969 + #ifdef FC_DUMMY_MAIN
8970 + #ifndef FC_DUMMY_MAIN_EQ_F77
8971 + #  ifdef __cplusplus
8972 +     extern "C"
8973 + #  endif
8974 +   int FC_DUMMY_MAIN() { return 1; }
8975 + #endif
8976 + #endif
8977 + int
8978 + main ()
8979 + {
8980 + return f != $ac_func;
8981 +  ;
8982 +  return 0;
8983 + }
8984   _ACEOF
8985 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
8986 <  $EGREP "memchr" >/dev/null 2>&1; then
8987 <  :
8985 > rm -f conftest.$ac_objext conftest$ac_exeext
8986 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8987 >  (eval $ac_link) 2>conftest.er1
8988 >  ac_status=$?
8989 >  grep -v '^ *+' conftest.er1 >conftest.err
8990 >  rm -f conftest.er1
8991 >  cat conftest.err >&5
8992 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8993 >  (exit $ac_status); } &&
8994 >         { ac_try='test -z "$ac_c_werror_flag"
8995 >                         || test ! -s conftest.err'
8996 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8997 >  (eval $ac_try) 2>&5
8998 >  ac_status=$?
8999 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9000 >  (exit $ac_status); }; } &&
9001 >         { ac_try='test -s conftest$ac_exeext'
9002 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9003 >  (eval $ac_try) 2>&5
9004 >  ac_status=$?
9005 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9006 >  (exit $ac_status); }; }; then
9007 >  eval "$as_ac_var=yes"
9008   else
9009 <  ac_cv_header_stdc=no
9010 < fi
4859 < rm -f conftest*
9009 >  echo "$as_me: failed program was:" >&5
9010 > sed 's/^/| /' conftest.$ac_ext >&5
9011  
9012 + eval "$as_ac_var=no"
9013   fi
9014 + rm -f conftest.err conftest.$ac_objext \
9015 +      conftest$ac_exeext conftest.$ac_ext
9016 + fi
9017 + echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9018 + echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9019 + if test `eval echo '${'$as_ac_var'}'` = yes; then
9020 +  cat >>confdefs.h <<_ACEOF
9021 + #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9022 + _ACEOF
9023  
9024 < if test $ac_cv_header_stdc = yes; then
9025 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
9026 <  cat >conftest.$ac_ext <<_ACEOF
9024 > else
9025 >  # strftime is in -lintl on SCO UNIX.
9026 > echo "$as_me:$LINENO: checking for strftime in -lintl" >&5
9027 > echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6
9028 > if test "${ac_cv_lib_intl_strftime+set}" = set; then
9029 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9030 > else
9031 >  ac_check_lib_save_LIBS=$LIBS
9032 > LIBS="-lintl  $LIBS"
9033 > cat >conftest.$ac_ext <<_ACEOF
9034   /* confdefs.h.  */
9035   _ACEOF
9036   cat confdefs.h >>conftest.$ac_ext
9037   cat >>conftest.$ac_ext <<_ACEOF
9038   /* end confdefs.h.  */
4871 – #include <stdlib.h>
9039  
9040 + /* Override any gcc2 internal prototype to avoid an error.  */
9041 + #ifdef __cplusplus
9042 + extern "C"
9043 + #endif
9044 + /* We use char because int might match the return type of a gcc2
9045 +   builtin and then its argument prototype would still apply.  */
9046 + char strftime ();
9047 + #ifdef FC_DUMMY_MAIN
9048 + #ifndef FC_DUMMY_MAIN_EQ_F77
9049 + #  ifdef __cplusplus
9050 +     extern "C"
9051 + #  endif
9052 +   int FC_DUMMY_MAIN() { return 1; }
9053 + #endif
9054 + #endif
9055 + int
9056 + main ()
9057 + {
9058 + strftime ();
9059 +  ;
9060 +  return 0;
9061 + }
9062   _ACEOF
9063 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
9064 <  $EGREP "free" >/dev/null 2>&1; then
9065 <  :
9063 > rm -f conftest.$ac_objext conftest$ac_exeext
9064 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9065 >  (eval $ac_link) 2>conftest.er1
9066 >  ac_status=$?
9067 >  grep -v '^ *+' conftest.er1 >conftest.err
9068 >  rm -f conftest.er1
9069 >  cat conftest.err >&5
9070 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9071 >  (exit $ac_status); } &&
9072 >         { ac_try='test -z "$ac_c_werror_flag"
9073 >                         || test ! -s conftest.err'
9074 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9075 >  (eval $ac_try) 2>&5
9076 >  ac_status=$?
9077 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9078 >  (exit $ac_status); }; } &&
9079 >         { ac_try='test -s conftest$ac_exeext'
9080 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9081 >  (eval $ac_try) 2>&5
9082 >  ac_status=$?
9083 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9084 >  (exit $ac_status); }; }; then
9085 >  ac_cv_lib_intl_strftime=yes
9086   else
9087 <  ac_cv_header_stdc=no
9087 >  echo "$as_me: failed program was:" >&5
9088 > sed 's/^/| /' conftest.$ac_ext >&5
9089 >
9090 > ac_cv_lib_intl_strftime=no
9091   fi
9092 < rm -f conftest*
9092 > rm -f conftest.err conftest.$ac_objext \
9093 >      conftest$ac_exeext conftest.$ac_ext
9094 > LIBS=$ac_check_lib_save_LIBS
9095 > fi
9096 > echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5
9097 > echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6
9098 > if test $ac_cv_lib_intl_strftime = yes; then
9099 >  cat >>confdefs.h <<\_ACEOF
9100 > #define HAVE_STRFTIME 1
9101 > _ACEOF
9102  
9103 + LIBS="-lintl $LIBS"
9104   fi
9105  
9106 < if test $ac_cv_header_stdc = yes; then
9107 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
9106 > fi
9107 > done
9108 >
9109 > echo "$as_me:$LINENO: checking for working strtod" >&5
9110 > echo $ECHO_N "checking for working strtod... $ECHO_C" >&6
9111 > if test "${ac_cv_func_strtod+set}" = set; then
9112 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9113 > else
9114    if test "$cross_compiling" = yes; then
9115 <  :
9115 >  ac_cv_func_strtod=no
9116   else
9117    cat >conftest.$ac_ext <<_ACEOF
9118   /* confdefs.h.  */
# Line 4892 | Line 9120 | cat >>conftest.$ac_ext <<_ACEOF
9120   cat confdefs.h >>conftest.$ac_ext
9121   cat >>conftest.$ac_ext <<_ACEOF
9122   /* end confdefs.h.  */
4895 – #include <ctype.h>
4896 – #if ((' ' & 0x0FF) == 0x020)
4897 – # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
4898 – # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
4899 – #else
4900 – # define ISLOWER(c) \
4901 –                   (('a' <= (c) && (c) <= 'i') \
4902 –                     || ('j' <= (c) && (c) <= 'r') \
4903 –                     || ('s' <= (c) && (c) <= 'z'))
4904 – # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
4905 – #endif
9123  
9124 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
9124 > double strtod ();
9125   int
9126 < main ()
9126 > main()
9127   {
9128 <  int i;
9129 <  for (i = 0; i < 256; i++)
9130 <    if (XOR (islower (i), ISLOWER (i))
9131 <        || toupper (i) != TOUPPER (i))
9132 <      exit(2);
9128 >  {
9129 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
9130 >    char *string = " +69";
9131 >    char *term;
9132 >    double value;
9133 >    value = strtod (string, &term);
9134 >    if (value != 69 || term != (string + 4))
9135 >      exit (1);
9136 >  }
9137 >
9138 >  {
9139 >    /* Under Solaris 2.4, strtod returns the wrong value for the
9140 >       terminating character under some conditions.  */
9141 >    char *string = "NaN";
9142 >    char *term;
9143 >    strtod (string, &term);
9144 >    if (term != string && *(term - 1) == 0)
9145 >      exit (1);
9146 >  }
9147    exit (0);
9148   }
9149 +
9150   _ACEOF
9151   rm -f conftest$ac_exeext
9152   if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
# Line 4927 | Line 9159 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9159    ac_status=$?
9160    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9161    (exit $ac_status); }; }; then
9162 <  :
9162 >  ac_cv_func_strtod=yes
9163   else
9164    echo "$as_me: program exited with status $ac_status" >&5
9165   echo "$as_me: failed program was:" >&5
9166   sed 's/^/| /' conftest.$ac_ext >&5
9167  
9168   ( exit $ac_status )
9169 < ac_cv_header_stdc=no
9169 > ac_cv_func_strtod=no
9170   fi
9171   rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9172   fi
9173   fi
9174 < fi
9175 < echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
9176 < echo "${ECHO_T}$ac_cv_header_stdc" >&6
9177 < if test $ac_cv_header_stdc = yes; then
9174 > echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
9175 > echo "${ECHO_T}$ac_cv_func_strtod" >&6
9176 > if test $ac_cv_func_strtod = no; then
9177 >  case $LIBOBJS in
9178 >    "strtod.$ac_objext"   | \
9179 >  *" strtod.$ac_objext"   | \
9180 >    "strtod.$ac_objext "* | \
9181 >  *" strtod.$ac_objext "* ) ;;
9182 >  *) LIBOBJS="$LIBOBJS strtod.$ac_objext" ;;
9183 > esac
9184  
9185 < cat >>confdefs.h <<\_ACEOF
9186 < #define STDC_HEADERS 1
9185 > echo "$as_me:$LINENO: checking for pow" >&5
9186 > echo $ECHO_N "checking for pow... $ECHO_C" >&6
9187 > if test "${ac_cv_func_pow+set}" = set; then
9188 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9189 > else
9190 >  cat >conftest.$ac_ext <<_ACEOF
9191 > /* confdefs.h.  */
9192   _ACEOF
9193 + cat confdefs.h >>conftest.$ac_ext
9194 + cat >>conftest.$ac_ext <<_ACEOF
9195 + /* end confdefs.h.  */
9196 + /* Define pow to an innocuous variant, in case <limits.h> declares pow.
9197 +   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9198 + #define pow innocuous_pow
9199  
9200 < fi
9200 > /* System header to define __stub macros and hopefully few prototypes,
9201 >    which can conflict with char pow (); below.
9202 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9203 >    <limits.h> exists even on freestanding compilers.  */
9204  
9205 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
9205 > #ifdef __STDC__
9206 > # include <limits.h>
9207 > #else
9208 > # include <assert.h>
9209 > #endif
9210  
9211 + #undef pow
9212  
9213 + /* Override any gcc2 internal prototype to avoid an error.  */
9214 + #ifdef __cplusplus
9215 + extern "C"
9216 + {
9217 + #endif
9218 + /* We use char because int might match the return type of a gcc2
9219 +   builtin and then its argument prototype would still apply.  */
9220 + char pow ();
9221 + /* The GNU C library defines this for functions which it implements
9222 +    to always fail with ENOSYS.  Some functions are actually named
9223 +    something starting with __ and the normal name is an alias.  */
9224 + #if defined (__stub_pow) || defined (__stub___pow)
9225 + choke me
9226 + #else
9227 + char (*f) () = pow;
9228 + #endif
9229 + #ifdef __cplusplus
9230 + }
9231 + #endif
9232  
9233 + #ifdef FC_DUMMY_MAIN
9234 + #ifndef FC_DUMMY_MAIN_EQ_F77
9235 + #  ifdef __cplusplus
9236 +     extern "C"
9237 + #  endif
9238 +   int FC_DUMMY_MAIN() { return 1; }
9239 + #endif
9240 + #endif
9241 + int
9242 + main ()
9243 + {
9244 + return f != pow;
9245 +  ;
9246 +  return 0;
9247 + }
9248 + _ACEOF
9249 + rm -f conftest.$ac_objext conftest$ac_exeext
9250 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9251 +  (eval $ac_link) 2>conftest.er1
9252 +  ac_status=$?
9253 +  grep -v '^ *+' conftest.er1 >conftest.err
9254 +  rm -f conftest.er1
9255 +  cat conftest.err >&5
9256 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9257 +  (exit $ac_status); } &&
9258 +         { ac_try='test -z "$ac_c_werror_flag"
9259 +                         || test ! -s conftest.err'
9260 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9261 +  (eval $ac_try) 2>&5
9262 +  ac_status=$?
9263 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9264 +  (exit $ac_status); }; } &&
9265 +         { ac_try='test -s conftest$ac_exeext'
9266 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9267 +  (eval $ac_try) 2>&5
9268 +  ac_status=$?
9269 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9270 +  (exit $ac_status); }; }; then
9271 +  ac_cv_func_pow=yes
9272 + else
9273 +  echo "$as_me: failed program was:" >&5
9274 + sed 's/^/| /' conftest.$ac_ext >&5
9275  
9276 + ac_cv_func_pow=no
9277 + fi
9278 + rm -f conftest.err conftest.$ac_objext \
9279 +      conftest$ac_exeext conftest.$ac_ext
9280 + fi
9281 + echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
9282 + echo "${ECHO_T}$ac_cv_func_pow" >&6
9283  
9284 <
9285 <
9286 <
9287 <
4963 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
4964 <                  inttypes.h stdint.h unistd.h
4965 < do
4966 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
4967 < echo "$as_me:$LINENO: checking for $ac_header" >&5
4968 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
4969 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
9284 > if test $ac_cv_func_pow = no; then
9285 >  echo "$as_me:$LINENO: checking for pow in -lm" >&5
9286 > echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6
9287 > if test "${ac_cv_lib_m_pow+set}" = set; then
9288    echo $ECHO_N "(cached) $ECHO_C" >&6
9289   else
9290 <  cat >conftest.$ac_ext <<_ACEOF
9290 >  ac_check_lib_save_LIBS=$LIBS
9291 > LIBS="-lm  $LIBS"
9292 > cat >conftest.$ac_ext <<_ACEOF
9293   /* confdefs.h.  */
9294   _ACEOF
9295   cat confdefs.h >>conftest.$ac_ext
9296   cat >>conftest.$ac_ext <<_ACEOF
9297   /* end confdefs.h.  */
4978 – $ac_includes_default
9298  
9299 < #include <$ac_header>
9299 > /* Override any gcc2 internal prototype to avoid an error.  */
9300 > #ifdef __cplusplus
9301 > extern "C"
9302 > #endif
9303 > /* We use char because int might match the return type of a gcc2
9304 >   builtin and then its argument prototype would still apply.  */
9305 > char pow ();
9306 > #ifdef FC_DUMMY_MAIN
9307 > #ifndef FC_DUMMY_MAIN_EQ_F77
9308 > #  ifdef __cplusplus
9309 >     extern "C"
9310 > #  endif
9311 >   int FC_DUMMY_MAIN() { return 1; }
9312 > #endif
9313 > #endif
9314 > int
9315 > main ()
9316 > {
9317 > pow ();
9318 >  ;
9319 >  return 0;
9320 > }
9321   _ACEOF
9322 < rm -f conftest.$ac_objext
9323 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9324 <  (eval $ac_compile) 2>conftest.er1
9322 > rm -f conftest.$ac_objext conftest$ac_exeext
9323 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9324 >  (eval $ac_link) 2>conftest.er1
9325    ac_status=$?
9326    grep -v '^ *+' conftest.er1 >conftest.err
9327    rm -f conftest.er1
9328    cat conftest.err >&5
9329    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9330    (exit $ac_status); } &&
9331 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9331 >         { ac_try='test -z "$ac_c_werror_flag"
9332 >                         || test ! -s conftest.err'
9333    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9334    (eval $ac_try) 2>&5
9335    ac_status=$?
9336    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9337    (exit $ac_status); }; } &&
9338 <         { ac_try='test -s conftest.$ac_objext'
9338 >         { ac_try='test -s conftest$ac_exeext'
9339    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9340    (eval $ac_try) 2>&5
9341    ac_status=$?
9342    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9343    (exit $ac_status); }; }; then
9344 <  eval "$as_ac_Header=yes"
9344 >  ac_cv_lib_m_pow=yes
9345   else
9346    echo "$as_me: failed program was:" >&5
9347   sed 's/^/| /' conftest.$ac_ext >&5
9348  
9349 < eval "$as_ac_Header=no"
9349 > ac_cv_lib_m_pow=no
9350   fi
9351 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9351 > rm -f conftest.err conftest.$ac_objext \
9352 >      conftest$ac_exeext conftest.$ac_ext
9353 > LIBS=$ac_check_lib_save_LIBS
9354   fi
9355 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9356 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9357 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
9358 <  cat >>confdefs.h <<_ACEOF
9359 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9360 < _ACEOF
9355 > echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
9356 > echo "${ECHO_T}$ac_cv_lib_m_pow" >&6
9357 > if test $ac_cv_lib_m_pow = yes; then
9358 >  POW_LIB=-lm
9359 > else
9360 >  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
9361 > echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
9362 > fi
9363  
9364   fi
9365  
9366 < done
9366 > fi
9367  
9368  
5024 – #
5025 – # Handle user hints
5026 – #
5027 – echo "$as_me:$LINENO: checking if zlib is wanted" >&5
5028 – echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
9369  
9370 < # Check whether --with-zlib or --without-zlib was given.
9371 < if test "${with_zlib+set}" = set; then
9372 <  withval="$with_zlib"
9373 <  if test "$withval" != no ; then
9374 <  echo "$as_me:$LINENO: result: yes" >&5
9375 < echo "${ECHO_T}yes" >&6
9376 <  if test -d "$withval"
9377 <  then
9378 <    ZLIB_HOME="$withval"
9379 <  else
9380 <    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
9381 < echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
9382 <  fi
9383 < else
9384 <  echo "$as_me:$LINENO: result: no" >&5
9385 < echo "${ECHO_T}no" >&6
9386 < fi
9387 < fi;
9370 >
9371 >
9372 >
9373 >
9374 >
9375 >
9376 >
9377 >
9378 >
9379 >
9380 >
9381 >
9382 >
9383 >
9384 >
9385 >
9386 >
9387 >
9388 >
9389 >
9390 >
9391  
5049 – ZLIB_HOME=/usr/local
5050 – if test ! -f "${ZLIB_HOME}/include/zlib.h"
5051 – then
5052 –        ZLIB_HOME=/usr
5053 – fi
9392  
5055 – #
5056 – # Locate zlib, if wanted
5057 – #
5058 – if test -n "${ZLIB_HOME}"
5059 – then
5060 –        ZLIB_OLD_LDFLAGS=$LDFLAGS
5061 –        ZLIB_OLD_CPPFLAGS=$LDFLAGS
5062 –        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5063 –        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
9393  
9394  
9395 <        ac_ext=c
9396 < ac_cpp='$CPP $CPPFLAGS'
9397 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9398 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9399 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
9400 <
5072 <        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5073 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5074 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
9395 > 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
9396 > do
9397 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9398 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9399 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9400 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9401    echo $ECHO_N "(cached) $ECHO_C" >&6
9402   else
9403 <  ac_check_lib_save_LIBS=$LIBS
5078 < LIBS="-lz  $LIBS"
5079 < cat >conftest.$ac_ext <<_ACEOF
9403 >  cat >conftest.$ac_ext <<_ACEOF
9404   /* confdefs.h.  */
9405   _ACEOF
9406   cat confdefs.h >>conftest.$ac_ext
9407   cat >>conftest.$ac_ext <<_ACEOF
9408   /* end confdefs.h.  */
9409 + /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9410 +   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9411 + #define $ac_func innocuous_$ac_func
9412  
9413 + /* System header to define __stub macros and hopefully few prototypes,
9414 +    which can conflict with char $ac_func (); below.
9415 +    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9416 +    <limits.h> exists even on freestanding compilers.  */
9417 +
9418 + #ifdef __STDC__
9419 + # include <limits.h>
9420 + #else
9421 + # include <assert.h>
9422 + #endif
9423 +
9424 + #undef $ac_func
9425 +
9426   /* Override any gcc2 internal prototype to avoid an error.  */
9427   #ifdef __cplusplus
9428   extern "C"
9429 + {
9430   #endif
9431   /* We use char because int might match the return type of a gcc2
9432     builtin and then its argument prototype would still apply.  */
9433 < char inflateEnd ();
9433 > char $ac_func ();
9434 > /* The GNU C library defines this for functions which it implements
9435 >    to always fail with ENOSYS.  Some functions are actually named
9436 >    something starting with __ and the normal name is an alias.  */
9437 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9438 > choke me
9439 > #else
9440 > char (*f) () = $ac_func;
9441 > #endif
9442 > #ifdef __cplusplus
9443 > }
9444 > #endif
9445 >
9446 > #ifdef FC_DUMMY_MAIN
9447 > #ifndef FC_DUMMY_MAIN_EQ_F77
9448 > #  ifdef __cplusplus
9449 >     extern "C"
9450 > #  endif
9451 >   int FC_DUMMY_MAIN() { return 1; }
9452 > #endif
9453 > #endif
9454   int
9455   main ()
9456   {
9457 < inflateEnd ();
9457 > return f != $ac_func;
9458    ;
9459    return 0;
9460   }
# Line 5107 | Line 9468 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9468    cat conftest.err >&5
9469    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9470    (exit $ac_status); } &&
9471 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9471 >         { ac_try='test -z "$ac_c_werror_flag"
9472 >                         || test ! -s conftest.err'
9473    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9474    (eval $ac_try) 2>&5
9475    ac_status=$?
# Line 5119 | Line 9481 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9481    ac_status=$?
9482    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9483    (exit $ac_status); }; }; then
9484 <  ac_cv_lib_z_inflateEnd=yes
9484 >  eval "$as_ac_var=yes"
9485   else
9486    echo "$as_me: failed program was:" >&5
9487   sed 's/^/| /' conftest.$ac_ext >&5
9488  
9489 < ac_cv_lib_z_inflateEnd=no
9489 > eval "$as_ac_var=no"
9490   fi
9491   rm -f conftest.err conftest.$ac_objext \
9492        conftest$ac_exeext conftest.$ac_ext
5131 – LIBS=$ac_check_lib_save_LIBS
9493   fi
9494 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
9495 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
9496 < if test $ac_cv_lib_z_inflateEnd = yes; then
9497 <  zlib_cv_libz=yes
9498 < else
5138 <  zlib_cv_libz=no
5139 < fi
5140 <
5141 <        if test "${ac_cv_header_zlib_h+set}" = set; then
5142 <  echo "$as_me:$LINENO: checking for zlib.h" >&5
5143 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5144 < if test "${ac_cv_header_zlib_h+set}" = set; then
5145 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5146 < fi
5147 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5148 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5149 < else
5150 <  # Is the header compilable?
5151 < echo "$as_me:$LINENO: checking zlib.h usability" >&5
5152 < echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
5153 < cat >conftest.$ac_ext <<_ACEOF
5154 < /* confdefs.h.  */
9494 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9495 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9496 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9497 >  cat >>confdefs.h <<_ACEOF
9498 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9499   _ACEOF
5156 – cat confdefs.h >>conftest.$ac_ext
5157 – cat >>conftest.$ac_ext <<_ACEOF
5158 – /* end confdefs.h.  */
5159 – $ac_includes_default
5160 – #include <zlib.h>
5161 – _ACEOF
5162 – rm -f conftest.$ac_objext
5163 – if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5164 –  (eval $ac_compile) 2>conftest.er1
5165 –  ac_status=$?
5166 –  grep -v '^ *+' conftest.er1 >conftest.err
5167 –  rm -f conftest.er1
5168 –  cat conftest.err >&5
5169 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5170 –  (exit $ac_status); } &&
5171 –         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
5172 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5173 –  (eval $ac_try) 2>&5
5174 –  ac_status=$?
5175 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5176 –  (exit $ac_status); }; } &&
5177 –         { ac_try='test -s conftest.$ac_objext'
5178 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5179 –  (eval $ac_try) 2>&5
5180 –  ac_status=$?
5181 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5182 –  (exit $ac_status); }; }; then
5183 –  ac_header_compiler=yes
5184 – else
5185 –  echo "$as_me: failed program was:" >&5
5186 – sed 's/^/| /' conftest.$ac_ext >&5
9500  
5188 – ac_header_compiler=no
9501   fi
9502 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5191 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
5192 < echo "${ECHO_T}$ac_header_compiler" >&6
9502 > done
9503  
5194 – # Is the header present?
5195 – echo "$as_me:$LINENO: checking zlib.h presence" >&5
5196 – echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
5197 – cat >conftest.$ac_ext <<_ACEOF
5198 – /* confdefs.h.  */
5199 – _ACEOF
5200 – cat confdefs.h >>conftest.$ac_ext
5201 – cat >>conftest.$ac_ext <<_ACEOF
5202 – /* end confdefs.h.  */
5203 – #include <zlib.h>
5204 – _ACEOF
5205 – if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5206 –  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5207 –  ac_status=$?
5208 –  grep -v '^ *+' conftest.er1 >conftest.err
5209 –  rm -f conftest.er1
5210 –  cat conftest.err >&5
5211 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5212 –  (exit $ac_status); } >/dev/null; then
5213 –  if test -s conftest.err; then
5214 –    ac_cpp_err=$ac_c_preproc_warn_flag
5215 –    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5216 –  else
5217 –    ac_cpp_err=
5218 –  fi
5219 – else
5220 –  ac_cpp_err=yes
5221 – fi
5222 – if test -z "$ac_cpp_err"; then
5223 –  ac_header_preproc=yes
5224 – else
5225 –  echo "$as_me: failed program was:" >&5
5226 – sed 's/^/| /' conftest.$ac_ext >&5
9504  
9505 <  ac_header_preproc=no
9506 < fi
9507 < rm -f conftest.err conftest.$ac_ext
9508 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
5232 < echo "${ECHO_T}$ac_header_preproc" >&6
5233 <
5234 < # So?  What about this header?
5235 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5236 <  yes:no: )
5237 <    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
5238 < echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
5239 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
5240 < echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
5241 <    ac_header_preproc=yes
5242 <    ;;
5243 <  no:yes:* )
5244 <    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
5245 < echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
5246 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
5247 < echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
5248 <    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
5249 < echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
5250 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
5251 < echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
5252 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
5253 < echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
5254 <    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
5255 < echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
5256 <    (
5257 <      cat <<\_ASBOX
5258 < ## ------------------------------ ##
5259 < ## Report this to gezelter@nd.edu ##
5260 < ## ------------------------------ ##
5261 < _ASBOX
5262 <    ) |
5263 <      sed "s/^/$as_me: WARNING:     /" >&2
5264 <    ;;
5265 < esac
5266 < echo "$as_me:$LINENO: checking for zlib.h" >&5
5267 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
5268 < if test "${ac_cv_header_zlib_h+set}" = set; then
5269 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5270 < else
5271 <  ac_cv_header_zlib_h=$ac_header_preproc
5272 < fi
5273 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
5274 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
5275 <
5276 < fi
5277 < if test $ac_cv_header_zlib_h = yes; then
5278 <  zlib_cv_zlib_h=yes
5279 < else
5280 <  zlib_cv_zlib_h=no
5281 < fi
5282 <
5283 <
5284 <        ac_ext=c
5285 < ac_cpp='$CPP $CPPFLAGS'
5286 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5287 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5288 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
5289 <
5290 <        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
5291 <        then
5292 <                #
5293 <                # If both library and header were found, use them
5294 <                #
5295 <
5296 < echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5297 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
5298 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5299 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5300 < else
5301 <  ac_check_lib_save_LIBS=$LIBS
5302 < LIBS="-lz  $LIBS"
9505 > # special check for _system_configuration because AIX <4.3.2 do not
9506 > # contain the `physmem' member.
9507 > echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
9508 > echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
9509   cat >conftest.$ac_ext <<_ACEOF
9510   /* confdefs.h.  */
9511   _ACEOF
9512   cat confdefs.h >>conftest.$ac_ext
9513   cat >>conftest.$ac_ext <<_ACEOF
9514   /* end confdefs.h.  */
9515 <
9516 < /* Override any gcc2 internal prototype to avoid an error.  */
9517 < #ifdef __cplusplus
9518 < extern "C"
9515 > #include <sys/systemcfg.h>
9516 > #ifdef FC_DUMMY_MAIN
9517 > #ifndef FC_DUMMY_MAIN_EQ_F77
9518 > #  ifdef __cplusplus
9519 >     extern "C"
9520 > #  endif
9521 >   int FC_DUMMY_MAIN() { return 1; }
9522   #endif
9523 < /* We use char because int might match the return type of a gcc2
5315 <   builtin and then its argument prototype would still apply.  */
5316 < char inflateEnd ();
9523 > #endif
9524   int
9525   main ()
9526   {
9527 < inflateEnd ();
9527 > double x = _system_configuration.physmem;
9528    ;
9529    return 0;
9530   }
9531   _ACEOF
9532 < rm -f conftest.$ac_objext conftest$ac_exeext
9533 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9534 <  (eval $ac_link) 2>conftest.er1
9532 > rm -f conftest.$ac_objext
9533 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9534 >  (eval $ac_compile) 2>conftest.er1
9535    ac_status=$?
9536    grep -v '^ *+' conftest.er1 >conftest.err
9537    rm -f conftest.er1
9538    cat conftest.err >&5
9539    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9540    (exit $ac_status); } &&
9541 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9541 >         { ac_try='test -z "$ac_c_werror_flag"
9542 >                         || test ! -s conftest.err'
9543    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9544    (eval $ac_try) 2>&5
9545    ac_status=$?
9546    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9547    (exit $ac_status); }; } &&
9548 <         { ac_try='test -s conftest$ac_exeext'
9548 >         { ac_try='test -s conftest.$ac_objext'
9549    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9550    (eval $ac_try) 2>&5
9551    ac_status=$?
9552    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9553    (exit $ac_status); }; }; then
9554 <  ac_cv_lib_z_inflateEnd=yes
9554 >  echo "$as_me:$LINENO: result: yes" >&5
9555 > echo "${ECHO_T}yes" >&6
9556 >
9557 > cat >>confdefs.h <<\_ACEOF
9558 > #define HAVE__SYSTEM_CONFIGURATION 1
9559 > _ACEOF
9560 >
9561   else
9562    echo "$as_me: failed program was:" >&5
9563   sed 's/^/| /' conftest.$ac_ext >&5
9564  
9565 < ac_cv_lib_z_inflateEnd=no
9565 > echo "$as_me:$LINENO: result: no" >&5
9566 > echo "${ECHO_T}no" >&6
9567   fi
9568 < rm -f conftest.err conftest.$ac_objext \
5354 <      conftest$ac_exeext conftest.$ac_ext
5355 < LIBS=$ac_check_lib_save_LIBS
5356 < fi
5357 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5358 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
5359 < if test $ac_cv_lib_z_inflateEnd = yes; then
5360 <  cat >>confdefs.h <<_ACEOF
5361 < #define HAVE_LIBZ 1
5362 < _ACEOF
9568 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9569  
9570 <  LIBS="-lz $LIBS"
9570 >  # clean out junk possibly left behind by a previous configuration
9571 >  rm -f src/getopt.h
9572 >  # Check for getopt_long support
9573  
9574 < fi
5367 <
5368 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
5369 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
5370 <                echo "$as_me:$LINENO: result: ok" >&5
5371 < echo "${ECHO_T}ok" >&6
5372 <        else
5373 <                #
5374 <                # If either header or library was not found, revert and bomb
5375 <                #
5376 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
5377 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
5378 <                LDFLAGS="$ZLIB_OLD_LDFLAGS"
5379 <                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
5380 <                echo "$as_me:$LINENO: result: failed" >&5
5381 < echo "${ECHO_T}failed" >&6
5382 <                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
5383 < echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
5384 <   { (exit 1); exit 1; }; }
5385 <        fi
5386 < fi
5387 <
5388 <
5389 <
5390 <
5391 <
5392 <
5393 <
5394 <
5395 < for ac_header in sys/time.h unistd.h stdlib.h stdio.h conio.h string.h
9574 > for ac_header in getopt.h
9575   do
9576   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9577   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 5425 | Line 9604 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9604    cat conftest.err >&5
9605    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9606    (exit $ac_status); } &&
9607 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9607 >         { ac_try='test -z "$ac_c_werror_flag"
9608 >                         || test ! -s conftest.err'
9609    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9610    (eval $ac_try) 2>&5
9611    ac_status=$?
# Line 5541 | Line 9721 | done
9721   done
9722  
9723  
9724 <
5545 <
5546 <
5547 <
5548 < for ac_header in strstream.h iostream.h fstream.h math.h time.h
9724 > for ac_func in getopt_long
9725   do
9726 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9727 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
9728 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
9729 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5554 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
9726 > as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
9727 > echo "$as_me:$LINENO: checking for $ac_func" >&5
9728 > echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
9729 > if eval "test \"\${$as_ac_var+set}\" = set"; then
9730    echo $ECHO_N "(cached) $ECHO_C" >&6
5556 – fi
5557 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
5558 – echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9731   else
9732 <  # Is the header compilable?
5561 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
5562 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
5563 < cat >conftest.$ac_ext <<_ACEOF
9732 >  cat >conftest.$ac_ext <<_ACEOF
9733   /* confdefs.h.  */
9734   _ACEOF
9735   cat confdefs.h >>conftest.$ac_ext
9736   cat >>conftest.$ac_ext <<_ACEOF
9737   /* end confdefs.h.  */
9738 < $ac_includes_default
9739 < #include <$ac_header>
9738 > /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
9739 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
9740 > #define $ac_func innocuous_$ac_func
9741 >
9742 > /* System header to define __stub macros and hopefully few prototypes,
9743 >    which can conflict with char $ac_func (); below.
9744 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9745 >    <limits.h> exists even on freestanding compilers.  */
9746 >
9747 > #ifdef __STDC__
9748 > # include <limits.h>
9749 > #else
9750 > # include <assert.h>
9751 > #endif
9752 >
9753 > #undef $ac_func
9754 >
9755 > /* Override any gcc2 internal prototype to avoid an error.  */
9756 > #ifdef __cplusplus
9757 > extern "C"
9758 > {
9759 > #endif
9760 > /* We use char because int might match the return type of a gcc2
9761 >   builtin and then its argument prototype would still apply.  */
9762 > char $ac_func ();
9763 > /* The GNU C library defines this for functions which it implements
9764 >    to always fail with ENOSYS.  Some functions are actually named
9765 >    something starting with __ and the normal name is an alias.  */
9766 > #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
9767 > choke me
9768 > #else
9769 > char (*f) () = $ac_func;
9770 > #endif
9771 > #ifdef __cplusplus
9772 > }
9773 > #endif
9774 >
9775 > #ifdef FC_DUMMY_MAIN
9776 > #ifndef FC_DUMMY_MAIN_EQ_F77
9777 > #  ifdef __cplusplus
9778 >     extern "C"
9779 > #  endif
9780 >   int FC_DUMMY_MAIN() { return 1; }
9781 > #endif
9782 > #endif
9783 > int
9784 > main ()
9785 > {
9786 > return f != $ac_func;
9787 >  ;
9788 >  return 0;
9789 > }
9790   _ACEOF
9791 < rm -f conftest.$ac_objext
9792 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9793 <  (eval $ac_compile) 2>conftest.er1
9791 > rm -f conftest.$ac_objext conftest$ac_exeext
9792 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9793 >  (eval $ac_link) 2>conftest.er1
9794    ac_status=$?
9795    grep -v '^ *+' conftest.er1 >conftest.err
9796    rm -f conftest.er1
9797    cat conftest.err >&5
9798    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9799    (exit $ac_status); } &&
9800 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
9800 >         { ac_try='test -z "$ac_c_werror_flag"
9801 >                         || test ! -s conftest.err'
9802    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9803    (eval $ac_try) 2>&5
9804    ac_status=$?
9805    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9806    (exit $ac_status); }; } &&
9807 <         { ac_try='test -s conftest.$ac_objext'
9807 >         { ac_try='test -s conftest$ac_exeext'
9808    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9809    (eval $ac_try) 2>&5
9810    ac_status=$?
9811    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9812    (exit $ac_status); }; }; then
9813 <  ac_header_compiler=yes
9813 >  eval "$as_ac_var=yes"
9814   else
9815    echo "$as_me: failed program was:" >&5
9816   sed 's/^/| /' conftest.$ac_ext >&5
9817  
9818 < ac_header_compiler=no
9818 > eval "$as_ac_var=no"
9819   fi
9820 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9821 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9822 < echo "${ECHO_T}$ac_header_compiler" >&6
9820 > rm -f conftest.err conftest.$ac_objext \
9821 >      conftest$ac_exeext conftest.$ac_ext
9822 > fi
9823 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
9824 > echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
9825 > if test `eval echo '${'$as_ac_var'}'` = yes; then
9826 >  cat >>confdefs.h <<_ACEOF
9827 > #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
9828 > _ACEOF
9829  
9830 < # Is the header present?
9831 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
9832 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9830 > else
9831 >  # FreeBSD has a gnugetopt library for this
9832 >    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
9833 > echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
9834 > if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
9835 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9836 > else
9837 >  ac_check_lib_save_LIBS=$LIBS
9838 > LIBS="-lgnugetopt  $LIBS"
9839   cat >conftest.$ac_ext <<_ACEOF
9840   /* confdefs.h.  */
9841   _ACEOF
9842   cat confdefs.h >>conftest.$ac_ext
9843   cat >>conftest.$ac_ext <<_ACEOF
9844   /* end confdefs.h.  */
9845 < #include <$ac_header>
9845 >
9846 > /* Override any gcc2 internal prototype to avoid an error.  */
9847 > #ifdef __cplusplus
9848 > extern "C"
9849 > #endif
9850 > /* We use char because int might match the return type of a gcc2
9851 >   builtin and then its argument prototype would still apply.  */
9852 > char getopt_long ();
9853 > #ifdef FC_DUMMY_MAIN
9854 > #ifndef FC_DUMMY_MAIN_EQ_F77
9855 > #  ifdef __cplusplus
9856 >     extern "C"
9857 > #  endif
9858 >   int FC_DUMMY_MAIN() { return 1; }
9859 > #endif
9860 > #endif
9861 > int
9862 > main ()
9863 > {
9864 > getopt_long ();
9865 >  ;
9866 >  return 0;
9867 > }
9868   _ACEOF
9869 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9870 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9869 > rm -f conftest.$ac_objext conftest$ac_exeext
9870 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9871 >  (eval $ac_link) 2>conftest.er1
9872    ac_status=$?
9873    grep -v '^ *+' conftest.er1 >conftest.err
9874    rm -f conftest.er1
9875    cat conftest.err >&5
9876    echo "$as_me:$LINENO: \$? = $ac_status" >&5
9877 <  (exit $ac_status); } >/dev/null; then
9878 <  if test -s conftest.err; then
9879 <    ac_cpp_err=$ac_c_preproc_warn_flag
9880 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9881 <  else
9882 <    ac_cpp_err=
9883 <  fi
9877 >  (exit $ac_status); } &&
9878 >         { ac_try='test -z "$ac_c_werror_flag"
9879 >                         || test ! -s conftest.err'
9880 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9881 >  (eval $ac_try) 2>&5
9882 >  ac_status=$?
9883 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9884 >  (exit $ac_status); }; } &&
9885 >         { ac_try='test -s conftest$ac_exeext'
9886 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9887 >  (eval $ac_try) 2>&5
9888 >  ac_status=$?
9889 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9890 >  (exit $ac_status); }; }; then
9891 >  ac_cv_lib_gnugetopt_getopt_long=yes
9892   else
5630 –  ac_cpp_err=yes
5631 – fi
5632 – if test -z "$ac_cpp_err"; then
5633 –  ac_header_preproc=yes
5634 – else
9893    echo "$as_me: failed program was:" >&5
9894   sed 's/^/| /' conftest.$ac_ext >&5
9895  
9896 <  ac_header_preproc=no
9896 > ac_cv_lib_gnugetopt_getopt_long=no
9897   fi
9898 < rm -f conftest.err conftest.$ac_ext
9899 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9900 < echo "${ECHO_T}$ac_header_preproc" >&6
9898 > rm -f conftest.err conftest.$ac_objext \
9899 >      conftest$ac_exeext conftest.$ac_ext
9900 > LIBS=$ac_check_lib_save_LIBS
9901 > fi
9902 > echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
9903 > echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
9904 > if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
9905 >  cat >>confdefs.h <<\_ACEOF
9906 > #define HAVE_GETOPT_LONG 1
9907 > _ACEOF
9908  
5644 – # So?  What about this header?
5645 – case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
5646 –  yes:no: )
5647 –    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
5648 – echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
5649 –    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
5650 – echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
5651 –    ac_header_preproc=yes
5652 –    ;;
5653 –  no:yes:* )
5654 –    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
5655 – echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
5656 –    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
5657 – echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
5658 –    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
5659 – echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
5660 –    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
5661 – echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
5662 –    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
5663 – echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
5664 –    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
5665 – echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
5666 –    (
5667 –      cat <<\_ASBOX
5668 – ## ------------------------------ ##
5669 – ## Report this to gezelter@nd.edu ##
5670 – ## ------------------------------ ##
5671 – _ASBOX
5672 –    ) |
5673 –      sed "s/^/$as_me: WARNING:     /" >&2
5674 –    ;;
5675 – esac
5676 – echo "$as_me:$LINENO: checking for $ac_header" >&5
5677 – echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5678 – if eval "test \"\${$as_ac_Header+set}\" = set"; then
5679 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9909   else
9910 <  eval "$as_ac_Header=\$ac_header_preproc"
9911 < fi
9912 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9913 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9910 >  # use the GNU replacement
9911 >      case $LIBOBJS in
9912 >    "getopt.$ac_objext"   | \
9913 >  *" getopt.$ac_objext"   | \
9914 >    "getopt.$ac_objext "* | \
9915 >  *" getopt.$ac_objext "* ) ;;
9916 >  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
9917 > esac
9918  
9919 < fi
9920 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
9921 <  cat >>confdefs.h <<_ACEOF
9922 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9923 < _ACEOF
9919 >      case $LIBOBJS in
9920 >    "getopt1.$ac_objext"   | \
9921 >  *" getopt1.$ac_objext"   | \
9922 >    "getopt1.$ac_objext "* | \
9923 >  *" getopt1.$ac_objext "* ) ;;
9924 >  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
9925 > esac
9926  
9927 +                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
9928 +
9929   fi
9930  
9931 + fi
9932   done
9933  
9934 +
9935   ac_ext=cc
9936   ac_cpp='$CXXCPP $CPPFLAGS'
9937   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9938   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9939   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9940  
9941 +
9942 + echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
9943 + echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
9944 + if test "${ac_cv_cxx_namespaces+set}" = set; then
9945 +  echo $ECHO_N "(cached) $ECHO_C" >&6
9946 + else
9947 +
9948 +
9949 + ac_ext=cc
9950 + ac_cpp='$CXXCPP $CPPFLAGS'
9951 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9952 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9953 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9954 +
9955 + cat >conftest.$ac_ext <<_ACEOF
9956 + /* confdefs.h.  */
9957 + _ACEOF
9958 + cat confdefs.h >>conftest.$ac_ext
9959 + cat >>conftest.$ac_ext <<_ACEOF
9960 + /* end confdefs.h.  */
9961 + namespace Outer { namespace Inner { int i = 0; }}
9962 + #ifdef FC_DUMMY_MAIN
9963 + #ifndef FC_DUMMY_MAIN_EQ_F77
9964 + #  ifdef __cplusplus
9965 +     extern "C"
9966 + #  endif
9967 +   int FC_DUMMY_MAIN() { return 1; }
9968 + #endif
9969 + #endif
9970 + int
9971 + main ()
9972 + {
9973 + using namespace Outer::Inner; return i;
9974 +  ;
9975 +  return 0;
9976 + }
9977 + _ACEOF
9978 + rm -f conftest.$ac_objext
9979 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9980 +  (eval $ac_compile) 2>conftest.er1
9981 +  ac_status=$?
9982 +  grep -v '^ *+' conftest.er1 >conftest.err
9983 +  rm -f conftest.er1
9984 +  cat conftest.err >&5
9985 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9986 +  (exit $ac_status); } &&
9987 +         { ac_try='test -z "$ac_cxx_werror_flag"
9988 +                         || test ! -s conftest.err'
9989 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9990 +  (eval $ac_try) 2>&5
9991 +  ac_status=$?
9992 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9993 +  (exit $ac_status); }; } &&
9994 +         { ac_try='test -s conftest.$ac_objext'
9995 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9996 +  (eval $ac_try) 2>&5
9997 +  ac_status=$?
9998 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9999 +  (exit $ac_status); }; }; then
10000 +  ac_cv_cxx_namespaces=yes
10001 + else
10002 +  echo "$as_me: failed program was:" >&5
10003 + sed 's/^/| /' conftest.$ac_ext >&5
10004 +
10005 + ac_cv_cxx_namespaces=no
10006 + fi
10007 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10008 + ac_ext=cc
10009 + ac_cpp='$CXXCPP $CPPFLAGS'
10010 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10011 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10012 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10013 +
10014 +
10015 + fi
10016 + echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
10017 + echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
10018 + if test "$ac_cv_cxx_namespaces" = yes; then
10019 +
10020 + cat >>confdefs.h <<\_ACEOF
10021 + #define HAVE_NAMESPACES
10022 + _ACEOF
10023 +
10024 + fi
10025 +
10026   ac_ext=cc
10027   ac_cpp='$CXXCPP $CPPFLAGS'
10028   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 5924 | Line 10248 | ac_ext=cc
10248   fi
10249  
10250   ac_ext=cc
10251 + ac_cpp='$CXXCPP $CPPFLAGS'
10252 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10253 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10254 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10255 +
10256 +
10257 + echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
10258 + echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
10259 + if test "${ac_cv_cxx_have_stl+set}" = set; then
10260 +  echo $ECHO_N "(cached) $ECHO_C" >&6
10261 + else
10262 +
10263 +
10264 +
10265 + ac_ext=cc
10266 + ac_cpp='$CXXCPP $CPPFLAGS'
10267 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10268 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10269 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10270 +
10271 + cat >conftest.$ac_ext <<_ACEOF
10272 + /* confdefs.h.  */
10273 + _ACEOF
10274 + cat confdefs.h >>conftest.$ac_ext
10275 + cat >>conftest.$ac_ext <<_ACEOF
10276 + /* end confdefs.h.  */
10277 + #include <list>
10278 + #include <deque>
10279 + #ifdef HAVE_NAMESPACES
10280 + using namespace std;
10281 + #endif
10282 + #ifdef FC_DUMMY_MAIN
10283 + #ifndef FC_DUMMY_MAIN_EQ_F77
10284 + #  ifdef __cplusplus
10285 +     extern "C"
10286 + #  endif
10287 +   int FC_DUMMY_MAIN() { return 1; }
10288 + #endif
10289 + #endif
10290 + int
10291 + main ()
10292 + {
10293 + list<int> x; x.push_back(5);
10294 + list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
10295 +  ;
10296 +  return 0;
10297 + }
10298 + _ACEOF
10299 + rm -f conftest.$ac_objext
10300 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10301 +  (eval $ac_compile) 2>conftest.er1
10302 +  ac_status=$?
10303 +  grep -v '^ *+' conftest.er1 >conftest.err
10304 +  rm -f conftest.er1
10305 +  cat conftest.err >&5
10306 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10307 +  (exit $ac_status); } &&
10308 +         { ac_try='test -z "$ac_cxx_werror_flag"
10309 +                         || test ! -s conftest.err'
10310 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10311 +  (eval $ac_try) 2>&5
10312 +  ac_status=$?
10313 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10314 +  (exit $ac_status); }; } &&
10315 +         { ac_try='test -s conftest.$ac_objext'
10316 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10317 +  (eval $ac_try) 2>&5
10318 +  ac_status=$?
10319 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10320 +  (exit $ac_status); }; }; then
10321 +  ac_cv_cxx_have_stl=yes
10322 + else
10323 +  echo "$as_me: failed program was:" >&5
10324 + sed 's/^/| /' conftest.$ac_ext >&5
10325 +
10326 + ac_cv_cxx_have_stl=no
10327 + fi
10328 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10329 + ac_ext=cc
10330   ac_cpp='$CXXCPP $CPPFLAGS'
10331   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10332   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10333   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10334  
10335  
10336 + fi
10337 + echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
10338 + echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
10339 + if test "$ac_cv_cxx_have_stl" = yes; then
10340  
10341 + cat >>confdefs.h <<\_ACEOF
10342 + #define HAVE_STL
10343 + _ACEOF
10344  
10345 + fi
10346  
10347  
10348  
10349 < for ac_header in ctype.h iostream fstream sstream strstream
10349 >  if test "${ac_cv_header_iostream+set}" = set; then
10350 >  echo "$as_me:$LINENO: checking for iostream" >&5
10351 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10352 > if test "${ac_cv_header_iostream+set}" = set; then
10353 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10354 > fi
10355 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10356 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10357 > else
10358 >  # Is the header compilable?
10359 > echo "$as_me:$LINENO: checking iostream usability" >&5
10360 > echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
10361 > cat >conftest.$ac_ext <<_ACEOF
10362 > /* confdefs.h.  */
10363 > _ACEOF
10364 > cat confdefs.h >>conftest.$ac_ext
10365 > cat >>conftest.$ac_ext <<_ACEOF
10366 > /* end confdefs.h.  */
10367 > $ac_includes_default
10368 > #include <iostream>
10369 > _ACEOF
10370 > rm -f conftest.$ac_objext
10371 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10372 >  (eval $ac_compile) 2>conftest.er1
10373 >  ac_status=$?
10374 >  grep -v '^ *+' conftest.er1 >conftest.err
10375 >  rm -f conftest.er1
10376 >  cat conftest.err >&5
10377 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10378 >  (exit $ac_status); } &&
10379 >         { ac_try='test -z "$ac_cxx_werror_flag"
10380 >                         || test ! -s conftest.err'
10381 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10382 >  (eval $ac_try) 2>&5
10383 >  ac_status=$?
10384 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10385 >  (exit $ac_status); }; } &&
10386 >         { ac_try='test -s conftest.$ac_objext'
10387 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10388 >  (eval $ac_try) 2>&5
10389 >  ac_status=$?
10390 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10391 >  (exit $ac_status); }; }; then
10392 >  ac_header_compiler=yes
10393 > else
10394 >  echo "$as_me: failed program was:" >&5
10395 > sed 's/^/| /' conftest.$ac_ext >&5
10396 >
10397 > ac_header_compiler=no
10398 > fi
10399 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10400 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10401 > echo "${ECHO_T}$ac_header_compiler" >&6
10402 >
10403 > # Is the header present?
10404 > echo "$as_me:$LINENO: checking iostream presence" >&5
10405 > echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
10406 > cat >conftest.$ac_ext <<_ACEOF
10407 > /* confdefs.h.  */
10408 > _ACEOF
10409 > cat confdefs.h >>conftest.$ac_ext
10410 > cat >>conftest.$ac_ext <<_ACEOF
10411 > /* end confdefs.h.  */
10412 > #include <iostream>
10413 > _ACEOF
10414 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10415 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10416 >  ac_status=$?
10417 >  grep -v '^ *+' conftest.er1 >conftest.err
10418 >  rm -f conftest.er1
10419 >  cat conftest.err >&5
10420 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10421 >  (exit $ac_status); } >/dev/null; then
10422 >  if test -s conftest.err; then
10423 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10424 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10425 >  else
10426 >    ac_cpp_err=
10427 >  fi
10428 > else
10429 >  ac_cpp_err=yes
10430 > fi
10431 > if test -z "$ac_cpp_err"; then
10432 >  ac_header_preproc=yes
10433 > else
10434 >  echo "$as_me: failed program was:" >&5
10435 > sed 's/^/| /' conftest.$ac_ext >&5
10436 >
10437 >  ac_header_preproc=no
10438 > fi
10439 > rm -f conftest.err conftest.$ac_ext
10440 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10441 > echo "${ECHO_T}$ac_header_preproc" >&6
10442 >
10443 > # So?  What about this header?
10444 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10445 >  yes:no: )
10446 >    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
10447 > echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
10448 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
10449 > echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
10450 >    ac_header_preproc=yes
10451 >    ;;
10452 >  no:yes:* )
10453 >    { echo "$as_me:$LINENO: WARNING: iostream: present but cannot be compiled" >&5
10454 > echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
10455 >    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
10456 > echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
10457 >    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
10458 > echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
10459 >    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
10460 > echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
10461 >    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
10462 > echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
10463 >    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
10464 > echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
10465 >    (
10466 >      cat <<\_ASBOX
10467 > ## ------------------------------ ##
10468 > ## Report this to gezelter@nd.edu ##
10469 > ## ------------------------------ ##
10470 > _ASBOX
10471 >    ) |
10472 >      sed "s/^/$as_me: WARNING:     /" >&2
10473 >    ;;
10474 > esac
10475 > echo "$as_me:$LINENO: checking for iostream" >&5
10476 > echo $ECHO_N "checking for iostream... $ECHO_C" >&6
10477 > if test "${ac_cv_header_iostream+set}" = set; then
10478 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10479 > else
10480 >  ac_cv_header_iostream=$ac_header_preproc
10481 > fi
10482 > echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
10483 > echo "${ECHO_T}$ac_cv_header_iostream" >&6
10484 >
10485 > fi
10486 > if test $ac_cv_header_iostream = yes; then
10487 >
10488 >
10489 > cat >>confdefs.h <<\_ACEOF
10490 > #define HAVE_IOSTREAM 1
10491 > _ACEOF
10492 >
10493 >
10494 > else
10495 >
10496 >
10497 > for ac_header in iostream.h
10498   do
10499   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10500   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 5968 | Line 10527 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10527    cat conftest.err >&5
10528    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10529    (exit $ac_status); } &&
10530 <         { ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
10530 >         { ac_try='test -z "$ac_cxx_werror_flag"
10531 >                         || test ! -s conftest.err'
10532    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10533    (eval $ac_try) 2>&5
10534    ac_status=$?
# Line 6083 | Line 10643 | done
10643  
10644   done
10645  
6086 – ac_ext=c
6087 – ac_cpp='$CPP $CPPFLAGS'
6088 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6089 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6090 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
10646  
10647 + fi
10648  
10649  
10650  
10651 < for ac_header in sys/pstat.h sys/sysmp.h sys/sysinfo.h
10652 < do
10653 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10654 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
10655 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
6100 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6101 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
10651 >
10652 >  if test "${ac_cv_header_iomanip+set}" = set; then
10653 >  echo "$as_me:$LINENO: checking for iomanip" >&5
10654 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10655 > if test "${ac_cv_header_iomanip+set}" = set; then
10656    echo $ECHO_N "(cached) $ECHO_C" >&6
10657   fi
10658 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10659 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10658 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10659 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10660   else
10661    # Is the header compilable?
10662 < echo "$as_me:$LINENO: checking $ac_header usability" >&5
10663 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10662 > echo "$as_me:$LINENO: checking iomanip usability" >&5
10663 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10664   cat >conftest.$ac_ext <<_ACEOF
10665   /* confdefs.h.  */
10666   _ACEOF
# Line 6114 | Line 10668 | $ac_includes_default
10668   cat >>conftest.$ac_ext <<_ACEOF
10669   /* end confdefs.h.  */
10670   $ac_includes_default
10671 < #include <$ac_header>
10671 > #include <iomanip>
10672   _ACEOF
10673   rm -f conftest.$ac_objext
10674   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6125 | Line 10679 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10679    cat conftest.err >&5
10680    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10681    (exit $ac_status); } &&
10682 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10682 >         { ac_try='test -z "$ac_cxx_werror_flag"
10683 >                         || test ! -s conftest.err'
10684    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10685    (eval $ac_try) 2>&5
10686    ac_status=$?
# Line 6149 | Line 10704 | echo "${ECHO_T}$ac_header_compiler" >&6
10704   echo "${ECHO_T}$ac_header_compiler" >&6
10705  
10706   # Is the header present?
10707 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
10708 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10707 > echo "$as_me:$LINENO: checking iomanip presence" >&5
10708 > echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
10709   cat >conftest.$ac_ext <<_ACEOF
10710   /* confdefs.h.  */
10711   _ACEOF
10712   cat confdefs.h >>conftest.$ac_ext
10713   cat >>conftest.$ac_ext <<_ACEOF
10714   /* end confdefs.h.  */
10715 < #include <$ac_header>
10715 > #include <iomanip>
10716   _ACEOF
10717   if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10718    (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
# Line 6168 | Line 10723 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10723    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10724    (exit $ac_status); } >/dev/null; then
10725    if test -s conftest.err; then
10726 <    ac_cpp_err=$ac_c_preproc_warn_flag
10727 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10726 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10727 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10728    else
10729      ac_cpp_err=
10730    fi
# Line 6189 | Line 10744 | echo "${ECHO_T}$ac_header_preproc" >&6
10744   echo "${ECHO_T}$ac_header_preproc" >&6
10745  
10746   # So?  What about this header?
10747 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10747 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10748    yes:no: )
10749 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10750 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10751 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10752 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10749 >    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
10750 > echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
10751 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
10752 > echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
10753      ac_header_preproc=yes
10754      ;;
10755    no:yes:* )
10756 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10757 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10758 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10759 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10760 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10761 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10762 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10763 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10764 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10765 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10766 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10767 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10756 >    { echo "$as_me:$LINENO: WARNING: iomanip: present but cannot be compiled" >&5
10757 > echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
10758 >    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
10759 > echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
10760 >    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
10761 > echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
10762 >    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
10763 > echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
10764 >    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
10765 > echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
10766 >    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
10767 > echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
10768      (
10769        cat <<\_ASBOX
10770   ## ------------------------------ ##
# Line 6220 | Line 10775 | esac
10775        sed "s/^/$as_me: WARNING:     /" >&2
10776      ;;
10777   esac
10778 < echo "$as_me:$LINENO: checking for $ac_header" >&5
10779 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10780 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
10778 > echo "$as_me:$LINENO: checking for iomanip" >&5
10779 > echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
10780 > if test "${ac_cv_header_iomanip+set}" = set; then
10781    echo $ECHO_N "(cached) $ECHO_C" >&6
10782   else
10783 <  eval "$as_ac_Header=\$ac_header_preproc"
10783 >  ac_cv_header_iomanip=$ac_header_preproc
10784   fi
10785 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10786 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10785 > echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
10786 > echo "${ECHO_T}$ac_cv_header_iomanip" >&6
10787  
10788   fi
10789 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
6235 <  cat >>confdefs.h <<_ACEOF
6236 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6237 < _ACEOF
10789 > if test $ac_cv_header_iomanip = yes; then
10790  
6239 – fi
10791  
10792 < done
10792 > cat >>confdefs.h <<\_ACEOF
10793 > #define HAVE_IOMANIP 1
10794 > _ACEOF
10795  
10796  
10797 + else
10798  
10799  
10800 <
6247 < for ac_header in sys/table.h sys/param.h sys/sysctl.h sys/sytemcfg.h
10800 > for ac_header in iomanip.h
10801   do
10802   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10803   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 6277 | Line 10830 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10830    cat conftest.err >&5
10831    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10832    (exit $ac_status); } &&
10833 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10833 >         { ac_try='test -z "$ac_cxx_werror_flag"
10834 >                         || test ! -s conftest.err'
10835    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10836    (eval $ac_try) 2>&5
10837    ac_status=$?
# Line 6320 | Line 10874 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
10874    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10875    (exit $ac_status); } >/dev/null; then
10876    if test -s conftest.err; then
10877 <    ac_cpp_err=$ac_c_preproc_warn_flag
10878 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
10877 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10878 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10879    else
10880      ac_cpp_err=
10881    fi
# Line 6341 | Line 10895 | echo "${ECHO_T}$ac_header_preproc" >&6
10895   echo "${ECHO_T}$ac_header_preproc" >&6
10896  
10897   # So?  What about this header?
10898 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10898 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10899    yes:no: )
10900      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10901   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 6393 | Line 10947 | done
10947   done
10948  
10949  
10950 < for ac_header in machine/hal_sysinfo.h
10950 > fi
10951 >
10952 >
10953 >
10954 >
10955 > for ac_header in cmath
10956   do
10957   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10958   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 6426 | Line 10985 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10985    cat conftest.err >&5
10986    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10987    (exit $ac_status); } &&
10988 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
10988 >         { ac_try='test -z "$ac_cxx_werror_flag"
10989 >                         || test ! -s conftest.err'
10990    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10991    (eval $ac_try) 2>&5
10992    ac_status=$?
# Line 6469 | Line 11029 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11029    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11030    (exit $ac_status); } >/dev/null; then
11031    if test -s conftest.err; then
11032 <    ac_cpp_err=$ac_c_preproc_warn_flag
11033 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11032 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11033 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11034    else
11035      ac_cpp_err=
11036    fi
# Line 6490 | Line 11050 | echo "${ECHO_T}$ac_header_preproc" >&6
11050   echo "${ECHO_T}$ac_header_preproc" >&6
11051  
11052   # So?  What about this header?
11053 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11053 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11054    yes:no: )
11055      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11056   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 6544 | Line 11104 | done
11104  
11105  
11106  
11107 <
11108 < for ac_func in rint snprintf sranddev strncasecmp
11109 < do
6550 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
6551 < echo "$as_me:$LINENO: checking for $ac_func" >&5
6552 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6553 < if eval "test \"\${$as_ac_var+set}\" = set"; then
11107 >  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
11108 > echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
11109 > if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
11110    echo $ECHO_N "(cached) $ECHO_C" >&6
11111   else
11112 <  cat >conftest.$ac_ext <<_ACEOF
11112 >
11113 >      ac_cv_cxx_have_std_iostream=no
11114 >      ac_cv_cxx_need_use_std_iostream=no
11115 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11116 >
11117 >
11118 >        ac_ext=cc
11119 > ac_cpp='$CXXCPP $CPPFLAGS'
11120 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11121 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11122 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11123 >
11124 >        cat >conftest.$ac_ext <<_ACEOF
11125   /* confdefs.h.  */
11126   _ACEOF
11127   cat confdefs.h >>conftest.$ac_ext
11128   cat >>conftest.$ac_ext <<_ACEOF
11129   /* end confdefs.h.  */
6562 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
6563 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
6564 – #define $ac_func innocuous_$ac_func
11130  
11131 < /* System header to define __stub macros and hopefully few prototypes,
11132 <    which can conflict with char $ac_func (); below.
6568 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6569 <    <limits.h> exists even on freestanding compilers.  */
6570 <
6571 < #ifdef __STDC__
6572 < # include <limits.h>
11131 > #ifdef HAVE_IOSTREAM
11132 > #include <iostream>
11133   #else
11134 < # include <assert.h>
11134 > #include <iostream.h>
11135   #endif
11136  
11137 < #undef $ac_func
11138 <
11139 < /* Override any gcc2 internal prototype to avoid an error.  */
11140 < #ifdef __cplusplus
11141 < extern "C"
11142 < {
11137 > #ifdef FC_DUMMY_MAIN
11138 > #ifndef FC_DUMMY_MAIN_EQ_F77
11139 > #  ifdef __cplusplus
11140 >     extern "C"
11141 > #  endif
11142 >   int FC_DUMMY_MAIN() { return 1; }
11143   #endif
6584 – /* We use char because int might match the return type of a gcc2
6585 –   builtin and then its argument prototype would still apply.  */
6586 – char $ac_func ();
6587 – /* The GNU C library defines this for functions which it implements
6588 –    to always fail with ENOSYS.  Some functions are actually named
6589 –    something starting with __ and the normal name is an alias.  */
6590 – #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6591 – choke me
6592 – #else
6593 – char (*f) () = $ac_func;
11144   #endif
6595 – #ifdef __cplusplus
6596 – }
6597 – #endif
6598 –
11145   int
11146   main ()
11147   {
11148 < return f != $ac_func;
11148 > std::cout<<"Hello World"<<std::endl;return 0;
11149    ;
11150    return 0;
11151   }
11152   _ACEOF
11153 < rm -f conftest.$ac_objext conftest$ac_exeext
11154 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11155 <  (eval $ac_link) 2>conftest.er1
11153 > rm -f conftest.$ac_objext
11154 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11155 >  (eval $ac_compile) 2>conftest.er1
11156    ac_status=$?
11157    grep -v '^ *+' conftest.er1 >conftest.err
11158    rm -f conftest.er1
11159    cat conftest.err >&5
11160    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11161    (exit $ac_status); } &&
11162 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11162 >         { ac_try='test -z "$ac_cxx_werror_flag"
11163 >                         || test ! -s conftest.err'
11164    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11165    (eval $ac_try) 2>&5
11166    ac_status=$?
11167    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11168    (exit $ac_status); }; } &&
11169 <         { ac_try='test -s conftest$ac_exeext'
11169 >         { ac_try='test -s conftest.$ac_objext'
11170    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11171    (eval $ac_try) 2>&5
11172    ac_status=$?
11173    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11174    (exit $ac_status); }; }; then
11175 <  eval "$as_ac_var=yes"
11175 >  ac_cv_cxx_have_std_iostream=yes
11176   else
11177    echo "$as_me: failed program was:" >&5
11178   sed 's/^/| /' conftest.$ac_ext >&5
11179  
6633 – eval "$as_ac_var=no"
11180   fi
11181 < rm -f conftest.err conftest.$ac_objext \
11182 <      conftest$ac_exeext conftest.$ac_ext
6637 < fi
6638 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
6639 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
6640 < if test `eval echo '${'$as_ac_var'}'` = yes; then
6641 <  cat >>confdefs.h <<_ACEOF
6642 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
6643 < _ACEOF
6644 <
6645 < fi
6646 < done
6647 <
6648 <
6649 <
6650 <
6651 <
6652 <
6653 < for ac_func in pstat_getstatic sysmp getsysinfo sysctl table
6654 < do
6655 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
6656 < echo "$as_me:$LINENO: checking for $ac_func" >&5
6657 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
6658 < if eval "test \"\${$as_ac_var+set}\" = set"; then
6659 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6660 < else
6661 <  cat >conftest.$ac_ext <<_ACEOF
11181 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11182 >        cat >conftest.$ac_ext <<_ACEOF
11183   /* confdefs.h.  */
11184   _ACEOF
11185   cat confdefs.h >>conftest.$ac_ext
11186   cat >>conftest.$ac_ext <<_ACEOF
11187   /* end confdefs.h.  */
6667 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
6668 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
6669 – #define $ac_func innocuous_$ac_func
11188  
11189 < /* System header to define __stub macros and hopefully few prototypes,
11190 <    which can conflict with char $ac_func (); below.
11191 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6674 <    <limits.h> exists even on freestanding compilers.  */
6675 <
6676 < #ifdef __STDC__
6677 < # include <limits.h>
11189 > #define __USE_STD_IOSTREAM 1
11190 > #ifdef HAVE_IOSTREAM
11191 > #include <iostream>
11192   #else
11193 < # include <assert.h>
11193 > #include <iostream.h>
11194   #endif
11195  
11196 < #undef $ac_func
11197 <
11198 < /* Override any gcc2 internal prototype to avoid an error.  */
11199 < #ifdef __cplusplus
11200 < extern "C"
11201 < {
11196 > #ifdef FC_DUMMY_MAIN
11197 > #ifndef FC_DUMMY_MAIN_EQ_F77
11198 > #  ifdef __cplusplus
11199 >     extern "C"
11200 > #  endif
11201 >   int FC_DUMMY_MAIN() { return 1; }
11202   #endif
6689 – /* We use char because int might match the return type of a gcc2
6690 –   builtin and then its argument prototype would still apply.  */
6691 – char $ac_func ();
6692 – /* The GNU C library defines this for functions which it implements
6693 –    to always fail with ENOSYS.  Some functions are actually named
6694 –    something starting with __ and the normal name is an alias.  */
6695 – #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
6696 – choke me
6697 – #else
6698 – char (*f) () = $ac_func;
11203   #endif
6700 – #ifdef __cplusplus
6701 – }
6702 – #endif
6703 –
11204   int
11205   main ()
11206   {
11207 < return f != $ac_func;
11207 > std::cout<<"Hello World"<<std::endl;return 0;
11208    ;
11209    return 0;
11210   }
11211   _ACEOF
11212 < rm -f conftest.$ac_objext conftest$ac_exeext
11213 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11214 <  (eval $ac_link) 2>conftest.er1
11212 > rm -f conftest.$ac_objext
11213 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11214 >  (eval $ac_compile) 2>conftest.er1
11215    ac_status=$?
11216    grep -v '^ *+' conftest.er1 >conftest.err
11217    rm -f conftest.er1
11218    cat conftest.err >&5
11219    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11220    (exit $ac_status); } &&
11221 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11221 >         { ac_try='test -z "$ac_cxx_werror_flag"
11222 >                         || test ! -s conftest.err'
11223    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11224    (eval $ac_try) 2>&5
11225    ac_status=$?
11226    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11227    (exit $ac_status); }; } &&
11228 <         { ac_try='test -s conftest$ac_exeext'
11228 >         { ac_try='test -s conftest.$ac_objext'
11229    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11230    (eval $ac_try) 2>&5
11231    ac_status=$?
11232    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11233    (exit $ac_status); }; }; then
11234 <  eval "$as_ac_var=yes"
11234 >  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
11235   else
11236    echo "$as_me: failed program was:" >&5
11237   sed 's/^/| /' conftest.$ac_ext >&5
11238  
6738 – eval "$as_ac_var=no"
11239   fi
11240 < rm -f conftest.err conftest.$ac_objext \
11241 <      conftest$ac_exeext conftest.$ac_ext
11242 < fi
11243 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
11244 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
11245 < if test `eval echo '${'$as_ac_var'}'` = yes; then
6746 <  cat >>confdefs.h <<_ACEOF
6747 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
6748 < _ACEOF
11240 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11241 >        ac_ext=cc
11242 > ac_cpp='$CXXCPP $CPPFLAGS'
11243 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11244 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11245 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11246  
11247 +      fi
11248 +
11249   fi
11250 < done
11250 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
11251 > echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
11252 >  if test "$ac_cv_cxx_have_std_iostream" = yes; then
11253  
11254 < # special check for _system_configuration because AIX <4.3.2 do not
11255 < # contain the `physmem' member.
6755 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
6756 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
6757 < cat >conftest.$ac_ext <<_ACEOF
6758 < /* confdefs.h.  */
11254 > cat >>confdefs.h <<\_ACEOF
11255 > #define HAVE_STD_IOSTREAM 1
11256   _ACEOF
6760 – cat confdefs.h >>conftest.$ac_ext
6761 – cat >>conftest.$ac_ext <<_ACEOF
6762 – /* end confdefs.h.  */
6763 – #include <sys/systemcfg.h>
6764 – int
6765 – main ()
6766 – {
6767 – double x = _system_configuration.physmem;
6768 –  ;
6769 –  return 0;
6770 – }
6771 – _ACEOF
6772 – rm -f conftest.$ac_objext
6773 – if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6774 –  (eval $ac_compile) 2>conftest.er1
6775 –  ac_status=$?
6776 –  grep -v '^ *+' conftest.er1 >conftest.err
6777 –  rm -f conftest.er1
6778 –  cat conftest.err >&5
6779 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6780 –  (exit $ac_status); } &&
6781 –         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
6782 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6783 –  (eval $ac_try) 2>&5
6784 –  ac_status=$?
6785 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6786 –  (exit $ac_status); }; } &&
6787 –         { ac_try='test -s conftest.$ac_objext'
6788 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6789 –  (eval $ac_try) 2>&5
6790 –  ac_status=$?
6791 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6792 –  (exit $ac_status); }; }; then
6793 –  echo "$as_me:$LINENO: result: yes" >&5
6794 – echo "${ECHO_T}yes" >&6
11257  
11258 +  fi
11259 +  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11260 +
11261   cat >>confdefs.h <<\_ACEOF
11262 < #define HAVE__SYSTEM_CONFIGURATION 1
11262 > #define __USE_STD_IOSTREAM 1
11263   _ACEOF
11264  
11265 < else
6801 <  echo "$as_me: failed program was:" >&5
6802 < sed 's/^/| /' conftest.$ac_ext >&5
11265 >  fi
11266  
11267 < echo "$as_me:$LINENO: result: no" >&5
11268 < echo "${ECHO_T}no" >&6
11269 < fi
11270 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11271 < echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
11272 < echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
6810 < if test "${ac_cv_header_time+set}" = set; then
11267 >
11268 >
11269 >
11270 >  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
11271 > echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
11272 > if test "${ac_cv_cxx_have_std_stl+set}" = set; then
11273    echo $ECHO_N "(cached) $ECHO_C" >&6
11274   else
11275 <  cat >conftest.$ac_ext <<_ACEOF
11275 >
11276 >      ac_cv_cxx_have_std_stl=no
11277 >      if test "x$ac_cv_cxx_namespaces" = xyes; then
11278 >
11279 >
11280 >        ac_ext=cc
11281 > ac_cpp='$CXXCPP $CPPFLAGS'
11282 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11283 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11284 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11285 >
11286 >        cat >conftest.$ac_ext <<_ACEOF
11287   /* confdefs.h.  */
11288   _ACEOF
11289   cat confdefs.h >>conftest.$ac_ext
11290   cat >>conftest.$ac_ext <<_ACEOF
11291   /* end confdefs.h.  */
11292 < #include <sys/types.h>
6820 < #include <sys/time.h>
6821 < #include <time.h>
11292 > #include <list>
11293  
11294 + #ifdef FC_DUMMY_MAIN
11295 + #ifndef FC_DUMMY_MAIN_EQ_F77
11296 + #  ifdef __cplusplus
11297 +     extern "C"
11298 + #  endif
11299 +   int FC_DUMMY_MAIN() { return 1; }
11300 + #endif
11301 + #endif
11302   int
11303   main ()
11304   {
11305 < if ((struct tm *) 0)
6827 < return 0;
11305 > std::list<int> foo;return 0;
11306    ;
11307    return 0;
11308   }
# Line 6838 | Line 11316 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11316    cat conftest.err >&5
11317    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11318    (exit $ac_status); } &&
11319 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11319 >         { ac_try='test -z "$ac_cxx_werror_flag"
11320 >                         || test ! -s conftest.err'
11321    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11322    (eval $ac_try) 2>&5
11323    ac_status=$?
# Line 6850 | Line 11329 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11329    ac_status=$?
11330    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11331    (exit $ac_status); }; }; then
11332 <  ac_cv_header_time=yes
11332 >  ac_cv_cxx_have_std_stl=yes
11333   else
11334    echo "$as_me: failed program was:" >&5
11335   sed 's/^/| /' conftest.$ac_ext >&5
11336  
6858 – ac_cv_header_time=no
11337   fi
11338   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11339 +        ac_ext=cc
11340 + ac_cpp='$CXXCPP $CPPFLAGS'
11341 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11342 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11343 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11344 +
11345 +      fi
11346 +
11347   fi
11348 < echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
11349 < echo "${ECHO_T}$ac_cv_header_time" >&6
11350 < if test $ac_cv_header_time = yes; then
11348 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
11349 > echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
11350 >  if test "$ac_cv_cxx_have_std_stl" = yes; then
11351  
11352   cat >>confdefs.h <<\_ACEOF
11353 < #define TIME_WITH_SYS_TIME 1
11353 > #define HAVE_STD_STL 1
11354   _ACEOF
11355  
11356 < fi
11356 >  fi
11357  
11358  
11359 < echo "$as_me:$LINENO: checking for clock_t" >&5
11360 < echo $ECHO_N "checking for clock_t... $ECHO_C" >&6
11361 < if test "${ac_cv_type_clock_t+set}" = set; then
11359 >
11360 >  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
11361 > echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
11362 > if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
11363    echo $ECHO_N "(cached) $ECHO_C" >&6
11364   else
11365 <  cat >conftest.$ac_ext <<_ACEOF
11365 >
11366 >    ac_cv_cxx_have_fstream_attach=no
11367 >
11368 >
11369 >    ac_ext=cc
11370 > ac_cpp='$CXXCPP $CPPFLAGS'
11371 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11372 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11373 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11374 >
11375 >    cat >conftest.$ac_ext <<_ACEOF
11376   /* confdefs.h.  */
11377   _ACEOF
11378   cat confdefs.h >>conftest.$ac_ext
11379   cat >>conftest.$ac_ext <<_ACEOF
11380   /* end confdefs.h.  */
11381 < $ac_includes_default
11381 >
11382 > #ifdef HAVE_IOSTREAM
11383 > #include <fstream>
11384 > #else
11385 > #include <fstream.h>
11386 > #endif
11387 > #ifdef HAVE_STD_IOSTREAM
11388 > using namespace std;
11389 > #endif
11390 >
11391 > #ifdef FC_DUMMY_MAIN
11392 > #ifndef FC_DUMMY_MAIN_EQ_F77
11393 > #  ifdef __cplusplus
11394 >     extern "C"
11395 > #  endif
11396 >   int FC_DUMMY_MAIN() { return 1; }
11397 > #endif
11398 > #endif
11399   int
11400   main ()
11401   {
11402 < if ((clock_t *) 0)
6889 <  return 0;
6890 < if (sizeof (clock_t))
6891 <  return 0;
11402 > int fd=0;ofstream s;s.attach(fd);
11403    ;
11404    return 0;
11405   }
# Line 6902 | Line 11413 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11413    cat conftest.err >&5
11414    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11415    (exit $ac_status); } &&
11416 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11416 >         { ac_try='test -z "$ac_cxx_werror_flag"
11417 >                         || test ! -s conftest.err'
11418    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11419    (eval $ac_try) 2>&5
11420    ac_status=$?
# Line 6914 | Line 11426 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11426    ac_status=$?
11427    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11428    (exit $ac_status); }; }; then
11429 <  ac_cv_type_clock_t=yes
11429 >  ac_cv_cxx_have_fstream_attach=yes
11430   else
11431    echo "$as_me: failed program was:" >&5
11432   sed 's/^/| /' conftest.$ac_ext >&5
11433  
6922 – ac_cv_type_clock_t=no
11434   fi
11435   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11436 +    ac_ext=cc
11437 + ac_cpp='$CXXCPP $CPPFLAGS'
11438 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11439 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11440 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11441 +
11442 +
11443   fi
11444 < echo "$as_me:$LINENO: result: $ac_cv_type_clock_t" >&5
11445 < echo "${ECHO_T}$ac_cv_type_clock_t" >&6
11446 < if test $ac_cv_type_clock_t = yes; then
11444 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
11445 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
11446 >  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
11447  
11448 < cat >>confdefs.h <<_ACEOF
11449 < #define HAVE_CLOCK_T 1
11448 > cat >>confdefs.h <<\_ACEOF
11449 > #define HAVE_FSTREAM_ATTACH 1
11450   _ACEOF
11451  
11452 +  fi
11453  
6935 – fi
11454  
11455 < echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
11456 < echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6
11457 < if test "${ac_cv_c_const+set}" = set; then
11455 >
11456 >  echo "$as_me:$LINENO: checking for fstream::open()" >&5
11457 > echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
11458 > if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
11459    echo $ECHO_N "(cached) $ECHO_C" >&6
11460   else
11461 <  cat >conftest.$ac_ext <<_ACEOF
11461 >
11462 >    ac_cv_cxx_have_fstream_open=no
11463 >    ac_cv_cxx_fstream_open_prot=no
11464 >
11465 >
11466 >    ac_ext=cc
11467 > ac_cpp='$CXXCPP $CPPFLAGS'
11468 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11469 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11470 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11471 >
11472 >    # Try with 2 parameters
11473 >    cat >conftest.$ac_ext <<_ACEOF
11474   /* confdefs.h.  */
11475   _ACEOF
11476   cat confdefs.h >>conftest.$ac_ext
11477   cat >>conftest.$ac_ext <<_ACEOF
11478   /* end confdefs.h.  */
11479  
11480 + #ifdef HAVE_IOSTREAM
11481 + #include <fstream>
11482 + #else
11483 + #include <fstream.h>
11484 + #endif
11485 + #ifdef HAVE_STD_IOSTREAM
11486 + using namespace std;
11487 + #endif
11488 +
11489 + #ifdef FC_DUMMY_MAIN
11490 + #ifndef FC_DUMMY_MAIN_EQ_F77
11491 + #  ifdef __cplusplus
11492 +     extern "C"
11493 + #  endif
11494 +   int FC_DUMMY_MAIN() { return 1; }
11495 + #endif
11496 + #endif
11497   int
11498   main ()
11499   {
11500 < /* FIXME: Include the comments suggested by Paul. */
6953 < #ifndef __cplusplus
6954 <  /* Ultrix mips cc rejects this.  */
6955 <  typedef int charset[2];
6956 <  const charset x;
6957 <  /* SunOS 4.1.1 cc rejects this.  */
6958 <  char const *const *ccp;
6959 <  char **p;
6960 <  /* NEC SVR4.0.2 mips cc rejects this.  */
6961 <  struct point {int x, y;};
6962 <  static struct point const zero = {0,0};
6963 <  /* AIX XL C 1.02.0.0 rejects this.
6964 <     It does not let you subtract one const X* pointer from another in
6965 <     an arm of an if-expression whose if-part is not a constant
6966 <     expression */
6967 <  const char *g = "string";
6968 <  ccp = &g + (g ? g-g : 0);
6969 <  /* HPUX 7.0 cc rejects these. */
6970 <  ++ccp;
6971 <  p = (char**) ccp;
6972 <  ccp = (char const *const *) p;
6973 <  { /* SCO 3.2v4 cc rejects this.  */
6974 <    char *t;
6975 <    char const *s = 0 ? (char *) 0 : (char const *) 0;
6976 <
6977 <    *t++ = 0;
6978 <  }
6979 <  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
6980 <    int x[] = {25, 17};
6981 <    const int *foo = &x[0];
6982 <    ++foo;
6983 <  }
6984 <  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
6985 <    typedef const int *iptr;
6986 <    iptr p = 0;
6987 <    ++p;
6988 <  }
6989 <  { /* AIX XL C 1.02.0.0 rejects this saying
6990 <       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
6991 <    struct s { int j; const int *ap[3]; };
6992 <    struct s *b; b->j = 5;
6993 <  }
6994 <  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
6995 <    const int foo = 10;
6996 <  }
6997 < #endif
6998 <
11500 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11501    ;
11502    return 0;
11503   }
# Line 7009 | Line 11511 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11511    cat conftest.err >&5
11512    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11513    (exit $ac_status); } &&
11514 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11514 >         { ac_try='test -z "$ac_cxx_werror_flag"
11515 >                         || test ! -s conftest.err'
11516    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11517    (eval $ac_try) 2>&5
11518    ac_status=$?
# Line 7021 | Line 11524 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11524    ac_status=$?
11525    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11526    (exit $ac_status); }; }; then
11527 <  ac_cv_c_const=yes
11527 >  ac_cv_cxx_have_fstream_open=yes
11528   else
11529    echo "$as_me: failed program was:" >&5
11530   sed 's/^/| /' conftest.$ac_ext >&5
11531  
7029 – ac_cv_c_const=no
11532   fi
11533   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11534 < fi
11535 < echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
7034 < echo "${ECHO_T}$ac_cv_c_const" >&6
7035 < if test $ac_cv_c_const = no; then
7036 <
7037 < cat >>confdefs.h <<\_ACEOF
7038 < #define const
7039 < _ACEOF
7040 <
7041 < fi
7042 <
7043 < echo "$as_me:$LINENO: checking for inline" >&5
7044 < echo $ECHO_N "checking for inline... $ECHO_C" >&6
7045 < if test "${ac_cv_c_inline+set}" = set; then
7046 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7047 < else
7048 <  ac_cv_c_inline=no
7049 < for ac_kw in inline __inline__ __inline; do
7050 <  cat >conftest.$ac_ext <<_ACEOF
11534 >    # Try with mode parameter
11535 >    cat >conftest.$ac_ext <<_ACEOF
11536   /* confdefs.h.  */
11537   _ACEOF
11538   cat confdefs.h >>conftest.$ac_ext
11539   cat >>conftest.$ac_ext <<_ACEOF
11540   /* end confdefs.h.  */
11541 < #ifndef __cplusplus
11542 < typedef int foo_t;
11543 < static $ac_kw foo_t static_foo () {return 0; }
11544 < $ac_kw foo_t foo () {return 0; }
11541 >
11542 > #ifdef HAVE_IOSTREAM
11543 > #include <fstream>
11544 > #else
11545 > #include <fstream.h>
11546   #endif
11547 + #ifdef HAVE_STD_IOSTREAM
11548 + using namespace std;
11549 + #endif
11550  
11551 + #ifdef FC_DUMMY_MAIN
11552 + #ifndef FC_DUMMY_MAIN_EQ_F77
11553 + #  ifdef __cplusplus
11554 +     extern "C"
11555 + #  endif
11556 +   int FC_DUMMY_MAIN() { return 1; }
11557 + #endif
11558 + #endif
11559 + int
11560 + main ()
11561 + {
11562 + ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
11563 +  ;
11564 +  return 0;
11565 + }
11566   _ACEOF
11567   rm -f conftest.$ac_objext
11568   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 7069 | Line 11573 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11573    cat conftest.err >&5
11574    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11575    (exit $ac_status); } &&
11576 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11576 >         { ac_try='test -z "$ac_cxx_werror_flag"
11577 >                         || test ! -s conftest.err'
11578    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11579    (eval $ac_try) 2>&5
11580    ac_status=$?
# Line 7081 | Line 11586 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11586    ac_status=$?
11587    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11588    (exit $ac_status); }; }; then
11589 <  ac_cv_c_inline=$ac_kw; break
11589 >  ac_cv_cxx_fstream_open_prot=yes
11590   else
11591    echo "$as_me: failed program was:" >&5
11592   sed 's/^/| /' conftest.$ac_ext >&5
11593  
11594   fi
11595   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11596 < done
11596 >    ac_ext=cc
11597 > ac_cpp='$CXXCPP $CPPFLAGS'
11598 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11599 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11600 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
11601  
11602 +
11603   fi
11604 < echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
11605 < echo "${ECHO_T}$ac_cv_c_inline" >&6
11604 > echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
11605 > echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
11606 >  if test "$ac_cv_cxx_have_fstream_open" = yes; then
11607  
11608 <
11609 < case $ac_cv_c_inline in
7099 <  inline | yes) ;;
7100 <  *)
7101 <    case $ac_cv_c_inline in
7102 <      no) ac_val=;;
7103 <      *) ac_val=$ac_cv_c_inline;;
7104 <    esac
7105 <    cat >>confdefs.h <<_ACEOF
7106 < #ifndef __cplusplus
7107 < #define inline $ac_val
7108 < #endif
11608 > cat >>confdefs.h <<\_ACEOF
11609 > #define HAVE_FSTREAM_OPEN 1
11610   _ACEOF
7110 –    ;;
7111 – esac
11611  
11612 +  fi
11613 +  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11614  
11615 <
11616 <
7116 < for ac_func in rint sranddev
7117 < do
7118 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7119 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7120 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7121 < if eval "test \"\${$as_ac_var+set}\" = set"; then
7122 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7123 < else
7124 <  cat >conftest.$ac_ext <<_ACEOF
7125 < /* confdefs.h.  */
11615 > cat >>confdefs.h <<\_ACEOF
11616 > #define FSTREAM_OPEN_PROT 1
11617   _ACEOF
7127 – cat confdefs.h >>conftest.$ac_ext
7128 – cat >>conftest.$ac_ext <<_ACEOF
7129 – /* end confdefs.h.  */
7130 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7131 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7132 – #define $ac_func innocuous_$ac_func
11618  
11619 < /* System header to define __stub macros and hopefully few prototypes,
7135 <    which can conflict with char $ac_func (); below.
7136 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7137 <    <limits.h> exists even on freestanding compilers.  */
11619 >  fi
11620  
7139 – #ifdef __STDC__
7140 – # include <limits.h>
7141 – #else
7142 – # include <assert.h>
7143 – #endif
11621  
7145 – #undef $ac_func
11622  
7147 – /* Override any gcc2 internal prototype to avoid an error.  */
7148 – #ifdef __cplusplus
7149 – extern "C"
7150 – {
7151 – #endif
7152 – /* We use char because int might match the return type of a gcc2
7153 –   builtin and then its argument prototype would still apply.  */
7154 – char $ac_func ();
7155 – /* The GNU C library defines this for functions which it implements
7156 –    to always fail with ENOSYS.  Some functions are actually named
7157 –    something starting with __ and the normal name is an alias.  */
7158 – #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7159 – choke me
7160 – #else
7161 – char (*f) () = $ac_func;
7162 – #endif
7163 – #ifdef __cplusplus
7164 – }
7165 – #endif
11623  
7167 – int
7168 – main ()
7169 – {
7170 – return f != $ac_func;
7171 –  ;
7172 –  return 0;
7173 – }
7174 – _ACEOF
7175 – rm -f conftest.$ac_objext conftest$ac_exeext
7176 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7177 –  (eval $ac_link) 2>conftest.er1
7178 –  ac_status=$?
7179 –  grep -v '^ *+' conftest.er1 >conftest.err
7180 –  rm -f conftest.er1
7181 –  cat conftest.err >&5
7182 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7183 –  (exit $ac_status); } &&
7184 –         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7185 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7186 –  (eval $ac_try) 2>&5
7187 –  ac_status=$?
7188 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7189 –  (exit $ac_status); }; } &&
7190 –         { ac_try='test -s conftest$ac_exeext'
7191 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7192 –  (eval $ac_try) 2>&5
7193 –  ac_status=$?
7194 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7195 –  (exit $ac_status); }; }; then
7196 –  eval "$as_ac_var=yes"
7197 – else
7198 –  echo "$as_me: failed program was:" >&5
7199 – sed 's/^/| /' conftest.$ac_ext >&5
11624  
7201 – eval "$as_ac_var=no"
7202 – fi
7203 – rm -f conftest.err conftest.$ac_objext \
7204 –      conftest$ac_exeext conftest.$ac_ext
7205 – fi
7206 – echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7207 – echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7208 – if test `eval echo '${'$as_ac_var'}'` = yes; then
7209 –  cat >>confdefs.h <<_ACEOF
7210 – #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7211 – _ACEOF
11625  
7213 – fi
7214 – done
11626  
11627 <
7217 <  # clean out junk possibly left behind by a previous configuration
7218 <  rm -f src/getopt.h
7219 <  # Check for getopt_long support
7220 <
7221 < for ac_header in getopt.h
11627 > for ac_header in ctype.h iostream fstream sstream strstream
11628   do
11629   as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11630   if eval "test \"\${$as_ac_Header+set}\" = set"; then
# Line 7251 | Line 11657 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11657    cat conftest.err >&5
11658    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11659    (exit $ac_status); } &&
11660 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11660 >         { ac_try='test -z "$ac_cxx_werror_flag"
11661 >                         || test ! -s conftest.err'
11662    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11663    (eval $ac_try) 2>&5
11664    ac_status=$?
# Line 7294 | Line 11701 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
11701    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11702    (exit $ac_status); } >/dev/null; then
11703    if test -s conftest.err; then
11704 <    ac_cpp_err=$ac_c_preproc_warn_flag
11705 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
11704 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
11705 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
11706    else
11707      ac_cpp_err=
11708    fi
# Line 7315 | Line 11722 | echo "${ECHO_T}$ac_header_preproc" >&6
11722   echo "${ECHO_T}$ac_header_preproc" >&6
11723  
11724   # So?  What about this header?
11725 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11725 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
11726    yes:no: )
11727      { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11728   echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
# Line 7366 | Line 11773 | done
11773  
11774   done
11775  
11776 + # AC_CPP_FUNC
11777 + # ------------------ #
11778 + # Checks to see if ANSI C99 CPP variable __func__ works.
11779 + # If not, perhaps __FUNCTION__ works instead.
11780 + # If not, we'll just define __func__ to "".
11781 + # AC_CPP_FUNC
11782  
11783 < for ac_func in getopt_long
11784 < do
11785 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11786 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7374 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7375 < if eval "test \"\${$as_ac_var+set}\" = set"; then
11783 >
11784 > echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
11785 > echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
11786 > if test "${ac_cv_cpp_func+set}" = set; then
11787    echo $ECHO_N "(cached) $ECHO_C" >&6
11788   else
11789    cat >conftest.$ac_ext <<_ACEOF
# Line 7381 | Line 11792 | cat >>conftest.$ac_ext <<_ACEOF
11792   cat confdefs.h >>conftest.$ac_ext
11793   cat >>conftest.$ac_ext <<_ACEOF
11794   /* end confdefs.h.  */
7384 – /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7385 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7386 – #define $ac_func innocuous_$ac_func
11795  
11796 < /* System header to define __stub macros and hopefully few prototypes,
11797 <    which can conflict with char $ac_func (); below.
11798 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11799 <    <limits.h> exists even on freestanding compilers.  */
11800 <
11801 < #ifdef __STDC__
7394 < # include <limits.h>
7395 < #else
7396 < # include <assert.h>
11796 > #ifdef FC_DUMMY_MAIN
11797 > #ifndef FC_DUMMY_MAIN_EQ_F77
11798 > #  ifdef __cplusplus
11799 >     extern "C"
11800 > #  endif
11801 >   int FC_DUMMY_MAIN() { return 1; }
11802   #endif
11803 + #endif
11804 + int
11805 + main ()
11806 + {
11807 + const char *foo = __func__;
11808 +  ;
11809 +  return 0;
11810 + }
11811 + _ACEOF
11812 + rm -f conftest.$ac_objext
11813 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11814 +  (eval $ac_compile) 2>conftest.er1
11815 +  ac_status=$?
11816 +  grep -v '^ *+' conftest.er1 >conftest.err
11817 +  rm -f conftest.er1
11818 +  cat conftest.err >&5
11819 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11820 +  (exit $ac_status); } &&
11821 +         { ac_try='test -z "$ac_cxx_werror_flag"
11822 +                         || test ! -s conftest.err'
11823 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11824 +  (eval $ac_try) 2>&5
11825 +  ac_status=$?
11826 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11827 +  (exit $ac_status); }; } &&
11828 +         { ac_try='test -s conftest.$ac_objext'
11829 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11830 +  (eval $ac_try) 2>&5
11831 +  ac_status=$?
11832 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11833 +  (exit $ac_status); }; }; then
11834 +  ac_cv_cpp_func=yes
11835 + else
11836 +  echo "$as_me: failed program was:" >&5
11837 + sed 's/^/| /' conftest.$ac_ext >&5
11838  
11839 < #undef $ac_func
11839 > cat >conftest.$ac_ext <<_ACEOF
11840 > /* confdefs.h.  */
11841 > _ACEOF
11842 > cat confdefs.h >>conftest.$ac_ext
11843 > cat >>conftest.$ac_ext <<_ACEOF
11844 > /* end confdefs.h.  */
11845  
11846 < /* Override any gcc2 internal prototype to avoid an error.  */
11847 < #ifdef __cplusplus
11848 < extern "C"
11849 < {
11846 > #ifdef FC_DUMMY_MAIN
11847 > #ifndef FC_DUMMY_MAIN_EQ_F77
11848 > #  ifdef __cplusplus
11849 >     extern "C"
11850 > #  endif
11851 >   int FC_DUMMY_MAIN() { return 1; }
11852   #endif
7406 – /* We use char because int might match the return type of a gcc2
7407 –   builtin and then its argument prototype would still apply.  */
7408 – char $ac_func ();
7409 – /* The GNU C library defines this for functions which it implements
7410 –    to always fail with ENOSYS.  Some functions are actually named
7411 –    something starting with __ and the normal name is an alias.  */
7412 – #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7413 – choke me
7414 – #else
7415 – char (*f) () = $ac_func;
11853   #endif
7417 – #ifdef __cplusplus
7418 – }
7419 – #endif
7420 –
11854   int
11855   main ()
11856   {
11857 < return f != $ac_func;
11857 > const char *foo = __FUNCTION__;
11858    ;
11859    return 0;
11860   }
11861   _ACEOF
11862 < rm -f conftest.$ac_objext conftest$ac_exeext
11863 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11864 <  (eval $ac_link) 2>conftest.er1
11862 > rm -f conftest.$ac_objext
11863 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11864 >  (eval $ac_compile) 2>conftest.er1
11865    ac_status=$?
11866    grep -v '^ *+' conftest.er1 >conftest.err
11867    rm -f conftest.er1
11868    cat conftest.err >&5
11869    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11870    (exit $ac_status); } &&
11871 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
11871 >         { ac_try='test -z "$ac_cxx_werror_flag"
11872 >                         || test ! -s conftest.err'
11873    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11874    (eval $ac_try) 2>&5
11875    ac_status=$?
11876    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11877    (exit $ac_status); }; } &&
11878 <         { ac_try='test -s conftest$ac_exeext'
11878 >         { ac_try='test -s conftest.$ac_objext'
11879    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11880    (eval $ac_try) 2>&5
11881    ac_status=$?
11882    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11883    (exit $ac_status); }; }; then
11884 <  eval "$as_ac_var=yes"
11884 >  ac_cv_cpp_func=__FUNCTION__
11885   else
11886    echo "$as_me: failed program was:" >&5
11887   sed 's/^/| /' conftest.$ac_ext >&5
11888  
11889 < eval "$as_ac_var=no"
11889 > ac_cv_cpp_func=no
11890   fi
11891 < rm -f conftest.err conftest.$ac_objext \
7458 <      conftest$ac_exeext conftest.$ac_ext
11891 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11892   fi
11893 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
11894 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
11895 < if test `eval echo '${'$as_ac_var'}'` = yes; then
11896 <  cat >>confdefs.h <<_ACEOF
11897 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
11893 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11894 > fi
11895 > echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
11896 > echo "${ECHO_T}$ac_cv_cpp_func" >&6
11897 > if test $ac_cv_cpp_func = __FUNCTION__; then
11898 >
11899 > cat >>confdefs.h <<\_ACEOF
11900 > #define __func__ __FUNCTION__
11901   _ACEOF
11902 +
11903 + elif test $ac_cv_cpp_func = no; then
11904 +
11905 + cat >>confdefs.h <<\_ACEOF
11906 + #define __func__ ""
11907 + _ACEOF
11908 +
11909 + fi
11910 +
11911 +
11912 +
11913 +
11914 +
11915 + case $debug in
11916 +  1)
11917 +     ;;
11918 +  *)
11919 +
11920 +
11921 +
11922 +
11923 + # Try to determine "good" native compiler flags if none specified on command
11924 + # line
11925 +
11926 + if test "$ac_test_FFLAGS" != "set"; then
11927 +  FCFLAGS=""
11928 +  case "${host_cpu}-${host_os}" in
11929 +
11930 +  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11931 +                    FCFLAGS="-O3 -ip -no-prec-div"
11932 +                fi;;
11933 +   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11934 +                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11935 +                fi;;
11936 +   powerpc*-aix*)
11937 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11938 +                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11939 +                echo "*******************************************************"
11940 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
11941 +                echo "*  recommended that you use                           *"
11942 +                echo "*                                                     *"
11943 +                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
11944 +                echo "*                                 ^^^                 *"
11945 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
11946 +                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
11947 +                echo "*******************************************************"
11948 +        fi;;
11949 +   *darwin*)
11950 +        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11951 +                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
11952 +        fi
11953 +        if test "$FC" = ifort; then
11954 +                FCFLAGS="-O3 -ip -no-prec-dev -mdynamic-no-pic"
11955 +        fi;;
11956 +  esac
11957 +
11958 +  if test -n "$CPU_FLAGS"; then
11959 +        FCFLAGS="$FCFLAGS $CPU_FLAGS"
11960 +  fi
11961 +
11962 +  if test -z "$FCFLAGS"; then
11963 +        echo ""
11964 +        echo "*********************************************************"
11965 +        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
11966 +        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11967 +        echo "* (otherwise, a default of FCFLAGS=-O3 will be used)    *"
11968 +        echo "*********************************************************"
11969 +        echo ""
11970 +        FCFLAGS="-O3"
11971 +  fi
11972 +
11973 +
11974 + echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
11975 + echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6
11976 + if test "${ac_guessed_f90flags+set}" = set; then
11977 +  echo $ECHO_N "(cached) $ECHO_C" >&6
11978 + else
11979 +
11980 +
11981 +
11982 + ac_ext=${FC_SRCEXT-f}
11983 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
11984 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
11985 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
11986 +
11987 + echo 'program main' > conftest.$ac_ext
11988 + echo 'end program main' >> conftest.$ac_ext
11989 + ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
11990 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11991 +  (eval $ac_compile) 2>&5
11992 +  ac_status=$?
11993 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11994 +  (exit $ac_status); }; then
11995 +        ac_guessed_f90flags=yes
11996 + else
11997 +        ac_guessed_f90flags=no
11998 + fi
11999 + rm -f conftest*
12000 + ac_ext=cc
12001 + ac_cpp='$CXXCPP $CPPFLAGS'
12002 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12003 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12004 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
12005 +
12006 +
12007 + fi
12008 + echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12009 + echo "${ECHO_T}$ac_guessed_f90flags" >&6
12010 + if test "$ac_guessed_f90flags" = yes; then
12011 +        :
12012  
12013   else
12014 <  # FreeBSD has a gnugetopt library for this
7469 <    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
7470 < echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
7471 < if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
7472 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7473 < else
7474 <  ac_check_lib_save_LIBS=$LIBS
7475 < LIBS="-lgnugetopt  $LIBS"
7476 < cat >conftest.$ac_ext <<_ACEOF
7477 < /* confdefs.h.  */
7478 < _ACEOF
7479 < cat confdefs.h >>conftest.$ac_ext
7480 < cat >>conftest.$ac_ext <<_ACEOF
7481 < /* end confdefs.h.  */
12014 >        :
12015  
12016 < /* Override any gcc2 internal prototype to avoid an error.  */
12017 < #ifdef __cplusplus
12018 < extern "C"
12019 < #endif
12020 < /* We use char because int might match the return type of a gcc2
12021 <   builtin and then its argument prototype would still apply.  */
12022 < char getopt_long ();
12023 < int
7491 < main ()
7492 < {
7493 < getopt_long ();
7494 <  ;
7495 <  return 0;
7496 < }
7497 < _ACEOF
7498 < rm -f conftest.$ac_objext conftest$ac_exeext
7499 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7500 <  (eval $ac_link) 2>conftest.er1
7501 <  ac_status=$?
7502 <  grep -v '^ *+' conftest.er1 >conftest.err
7503 <  rm -f conftest.er1
7504 <  cat conftest.err >&5
7505 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7506 <  (exit $ac_status); } &&
7507 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
7508 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7509 <  (eval $ac_try) 2>&5
7510 <  ac_status=$?
7511 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7512 <  (exit $ac_status); }; } &&
7513 <         { ac_try='test -s conftest$ac_exeext'
7514 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
7515 <  (eval $ac_try) 2>&5
7516 <  ac_status=$?
7517 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7518 <  (exit $ac_status); }; }; then
7519 <  ac_cv_lib_gnugetopt_getopt_long=yes
7520 < else
7521 <  echo "$as_me: failed program was:" >&5
7522 < sed 's/^/| /' conftest.$ac_ext >&5
12016 >        echo ""
12017 >        echo "**********************************************************"
12018 >        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12019 >        echo "* your compiler.                                        *"
12020 >        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12021 >        echo "*********************************************************"
12022 >        echo ""
12023 >        FCFLAGS=""
12024  
7524 – ac_cv_lib_gnugetopt_getopt_long=no
12025   fi
7526 – rm -f conftest.err conftest.$ac_objext \
7527 –      conftest$ac_exeext conftest.$ac_ext
7528 – LIBS=$ac_check_lib_save_LIBS
7529 – fi
7530 – echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
7531 – echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
7532 – if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
7533 –  cat >>confdefs.h <<\_ACEOF
7534 – #define HAVE_GETOPT_LONG 1
7535 – _ACEOF
12026  
7537 – else
7538 –  # use the GNU replacement
7539 –      case $LIBOBJS in
7540 –    "getopt.$ac_objext"   | \
7541 –  *" getopt.$ac_objext"   | \
7542 –    "getopt.$ac_objext "* | \
7543 –  *" getopt.$ac_objext "* ) ;;
7544 –  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
7545 – esac
12027  
7547 –      case $LIBOBJS in
7548 –    "getopt1.$ac_objext"   | \
7549 –  *" getopt1.$ac_objext"   | \
7550 –    "getopt1.$ac_objext "* | \
7551 –  *" getopt1.$ac_objext "* ) ;;
7552 –  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
7553 – esac
7554 –
7555 –                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
7556 –
12028   fi
12029  
7559 – fi
7560 – done
12030  
12031  
12032  
7564 – case $debug in
7565 –  1)
7566 –     ;;
7567 –  *)
12033  
12034  
12035  
7571 –
7572 –
7573 –
12036   echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
12037   echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6
12038   if test "${ac_cv_prog_really_gcc+set}" = set; then
# Line 7579 | Line 12041 | cat > conftest.c <<EOF
12041  
12042   cat > conftest.c <<EOF
12043   #ifdef __GNUC__
12044 <  #ifndef __INTEL_COMPILER
12044 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12045 >     no;
12046 >  #else
12047       yes;
12048    #endif
12049   #endif
# Line 7617 | Line 12081 | if test "$ac_test_CFLAGS" != "set"; then
12081                      CFLAGS="-O"
12082                  fi;;
12083    sparc-solaris2*) if test "$CC" = cc; then
12084 <                    CFLAGS="-native -fast -xO5 -dalign"
12084 >                    CFLAGS="-O -dalign"
12085                   fi;;
12086  
12087    alpha*-osf*)  if test "$CC" = cc; then
# Line 7647 | Line 12111 | if test "$ac_test_CFLAGS" != "set"; then
12111     *darwin*)
12112          if test "$CC" = xlc -o "$CC" = cc; then
12113                  CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12114 +        fi
12115 +        if test "$CC" = icc; then
12116 +                CFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12117          fi;;
12118    esac
12119  
# Line 7660 | Line 12127 | if test "$ac_test_CFLAGS" != "set"; then
12127      # -malign-double for x86 systems
12128  
12129  
12130 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -malign-double" >&5
12131 < echo $ECHO_N "checking whether ${CC-cc} accepts -malign-double... $ECHO_C" >&6
12130 > echo "$as_me:$LINENO: checking whether ${CC} accepts -malign-double" >&5
12131 > echo $ECHO_N "checking whether ${CC} accepts -malign-double... $ECHO_C" >&6
12132   if test "${ac_align_double+set}" = set; then
12133    echo $ECHO_N "(cached) $ECHO_C" >&6
12134   else
12135    echo 'void f(){}' > conftest.c
12136 < if test -z "`${CC-cc} -malign-double -c conftest.c 2>&1`"; then
12136 > if test -z "`${CC} -malign-double -c conftest.c 2>&1`"; then
12137          ac_align_double=yes
12138   else
12139          ac_align_double=no
# Line 7687 | Line 12154 | fi
12154      # -fstrict-aliasing for gcc-2.95+
12155  
12156  
12157 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -fstrict-aliasing" >&5
12158 < echo $ECHO_N "checking whether ${CC-cc} accepts -fstrict-aliasing... $ECHO_C" >&6
12157 > echo "$as_me:$LINENO: checking whether ${CC} accepts -fstrict-aliasing" >&5
12158 > echo $ECHO_N "checking whether ${CC} accepts -fstrict-aliasing... $ECHO_C" >&6
12159   if test "${ac_fstrict_aliasing+set}" = set; then
12160    echo $ECHO_N "(cached) $ECHO_C" >&6
12161   else
12162    echo 'void f(){}' > conftest.c
12163 < if test -z "`${CC-cc} -fstrict-aliasing -c conftest.c 2>&1`"; then
12163 > if test -z "`${CC} -fstrict-aliasing -c conftest.c 2>&1`"; then
12164          ac_fstrict_aliasing=yes
12165   else
12166          ac_fstrict_aliasing=no
# Line 7718 | Line 12185 | fi
12185                    case "${host_cpu}" in
12186            i586*)
12187  
12188 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentium" >&5
12189 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentium... $ECHO_C" >&6
12188 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentium" >&5
12189 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentium... $ECHO_C" >&6
12190   if test "${ac_cpu_pentium+set}" = set; then
12191    echo $ECHO_N "(cached) $ECHO_C" >&6
12192   else
12193    echo 'void f(){}' > conftest.c
12194 < if test -z "`${CC-cc} -mcpu=pentium -c conftest.c 2>&1`"; then
12194 > if test -z "`${CC} -mcpu=pentium -c conftest.c 2>&1`"; then
12195          ac_cpu_pentium=yes
12196   else
12197          ac_cpu_pentium=no
# Line 7741 | Line 12208 | else
12208          :
12209  
12210  
12211 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentium" >&5
12212 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentium... $ECHO_C" >&6
12211 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentium" >&5
12212 > echo $ECHO_N "checking whether ${CC} accepts -mpentium... $ECHO_C" >&6
12213   if test "${ac_pentium+set}" = set; then
12214    echo $ECHO_N "(cached) $ECHO_C" >&6
12215   else
12216    echo 'void f(){}' > conftest.c
12217 < if test -z "`${CC-cc} -mpentium -c conftest.c 2>&1`"; then
12217 > if test -z "`${CC} -mpentium -c conftest.c 2>&1`"; then
12218          ac_pentium=yes
12219   else
12220          ac_pentium=no
# Line 7770 | Line 12237 | fi
12237                    ;;
12238            i686*)
12239  
12240 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=pentiumpro" >&5
12241 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12240 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=pentiumpro" >&5
12241 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12242   if test "${ac_cpu_pentiumpro+set}" = set; then
12243    echo $ECHO_N "(cached) $ECHO_C" >&6
12244   else
12245    echo 'void f(){}' > conftest.c
12246 < if test -z "`${CC-cc} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12246 > if test -z "`${CC} -mcpu=pentiumpro -c conftest.c 2>&1`"; then
12247          ac_cpu_pentiumpro=yes
12248   else
12249          ac_cpu_pentiumpro=no
# Line 7793 | Line 12260 | else
12260          :
12261  
12262  
12263 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpentiumpro" >&5
12264 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpentiumpro... $ECHO_C" >&6
12263 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpentiumpro" >&5
12264 > echo $ECHO_N "checking whether ${CC} accepts -mpentiumpro... $ECHO_C" >&6
12265   if test "${ac_pentiumpro+set}" = set; then
12266    echo $ECHO_N "(cached) $ECHO_C" >&6
12267   else
12268    echo 'void f(){}' > conftest.c
12269 < if test -z "`${CC-cc} -mpentiumpro -c conftest.c 2>&1`"; then
12269 > if test -z "`${CC} -mpentiumpro -c conftest.c 2>&1`"; then
12270          ac_pentiumpro=yes
12271   else
12272          ac_pentiumpro=no
# Line 7826 | Line 12293 | fi
12293                  if test -n "$is60x"; then
12294  
12295  
12296 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=$cputype" >&5
12297 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=$cputype... $ECHO_C" >&6
12296 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=$cputype" >&5
12297 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=$cputype... $ECHO_C" >&6
12298   if test "${ac_m_cpu_60x+set}" = set; then
12299    echo $ECHO_N "(cached) $ECHO_C" >&6
12300   else
12301    echo 'void f(){}' > conftest.c
12302 < if test -z "`${CC-cc} -mcpu=$cputype -c conftest.c 2>&1`"; then
12302 > if test -z "`${CC} -mcpu=$cputype -c conftest.c 2>&1`"; then
12303          ac_m_cpu_60x=yes
12304   else
12305          ac_m_cpu_60x=no
# Line 7884 | Line 12351 | if test "$ac_cv_prog_gcc_2_95" = yes; then
12351          :
12352  
12353  
12354 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=750" >&5
12355 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=750... $ECHO_C" >&6
12354 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=750" >&5
12355 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=750... $ECHO_C" >&6
12356   if test "${ac_m_cpu_750+set}" = set; then
12357    echo $ECHO_N "(cached) $ECHO_C" >&6
12358   else
12359    echo 'void f(){}' > conftest.c
12360 < if test -z "`${CC-cc} -mcpu=750 -c conftest.c 2>&1`"; then
12360 > if test -z "`${CC} -mcpu=750 -c conftest.c 2>&1`"; then
12361          ac_m_cpu_750=yes
12362   else
12363          ac_m_cpu_750=no
# Line 7917 | Line 12384 | fi
12384                  if test -z "$CPU_FLAGS"; then
12385  
12386  
12387 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mcpu=powerpc" >&5
12388 < echo $ECHO_N "checking whether ${CC-cc} accepts -mcpu=powerpc... $ECHO_C" >&6
12387 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mcpu=powerpc" >&5
12388 > echo $ECHO_N "checking whether ${CC} accepts -mcpu=powerpc... $ECHO_C" >&6
12389   if test "${ac_m_cpu_powerpc+set}" = set; then
12390    echo $ECHO_N "(cached) $ECHO_C" >&6
12391   else
12392    echo 'void f(){}' > conftest.c
12393 < if test -z "`${CC-cc} -mcpu=powerpc -c conftest.c 2>&1`"; then
12393 > if test -z "`${CC} -mcpu=powerpc -c conftest.c 2>&1`"; then
12394          ac_m_cpu_powerpc=yes
12395   else
12396          ac_m_cpu_powerpc=no
# Line 7945 | Line 12412 | fi
12412                  if test -z "$CPU_FLAGS"; then
12413  
12414  
12415 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts -mpowerpc" >&5
12416 < echo $ECHO_N "checking whether ${CC-cc} accepts -mpowerpc... $ECHO_C" >&6
12415 > echo "$as_me:$LINENO: checking whether ${CC} accepts -mpowerpc" >&5
12416 > echo $ECHO_N "checking whether ${CC} accepts -mpowerpc... $ECHO_C" >&6
12417   if test "${ac_m_powerpc+set}" = set; then
12418    echo $ECHO_N "(cached) $ECHO_C" >&6
12419   else
12420    echo 'void f(){}' > conftest.c
12421 < if test -z "`${CC-cc} -mpowerpc -c conftest.c 2>&1`"; then
12421 > if test -z "`${CC} -mpowerpc -c conftest.c 2>&1`"; then
12422          ac_m_powerpc=yes
12423   else
12424          ac_m_powerpc=no
# Line 7990 | Line 12457 | fi
12457  
12458  
12459  
12460 < echo "$as_me:$LINENO: checking whether ${CC-cc} accepts ${CFLAGS}" >&5
12461 < echo $ECHO_N "checking whether ${CC-cc} accepts ${CFLAGS}... $ECHO_C" >&6
12460 > echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
12461 > echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6
12462   if test "${ac_guessed_cflags+set}" = set; then
12463    echo $ECHO_N "(cached) $ECHO_C" >&6
12464   else
12465    echo 'void f(){}' > conftest.c
12466 < if test -z "`${CC-cc} ${CFLAGS} -c conftest.c 2>&1`"; then
12466 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
12467          ac_guessed_cflags=yes
12468   else
12469          ac_guessed_cflags=no
# Line 8040 | Line 12507 | cat > conftest.cpp <<EOF
12507  
12508   cat > conftest.cpp <<EOF
12509   #ifdef __GNUC__
12510 <  #ifndef __INTEL_COMPILER
12510 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12511 >     no;
12512 >  #else
12513       yes;
12514    #endif
12515   #endif
# Line 8078 | Line 12547 | if test "$ac_test_CXXFLAGS" != "set"; then
12547                      CXXFLAGS="-O"
12548                  fi;;
12549    sparc-solaris2*) if test "$CXX" = CC; then
12550 <                    CXXFLAGS="-native -fast -xO5 -dalign"
12550 >                    CXXFLAGS="-features=extensions -O -dalign"
12551                   fi;;
12552     rs6000*-aix*)  if test "$CXX" = xlC; then
12553                      CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
# Line 8099 | Line 12568 | if test "$ac_test_CXXFLAGS" != "set"; then
12568     *darwin*)
12569          if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12570                  CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12571 +        fi
12572 +        if test "$CXX" = icpc; then
12573 +                CXXFLAGS="-O3 -ip -no-prec-div -mdynamic-no-pic"
12574          fi;;
12575    esac
12576  
# Line 8112 | Line 12584 | if test "$ac_test_CXXFLAGS" != "set"; then
12584      # -malign-double for x86 systems
12585  
12586  
12587 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -malign-double" >&5
12588 < echo $ECHO_N "checking whether ${CXX-c++} accepts -malign-double... $ECHO_C" >&6
12587 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -malign-double" >&5
12588 > echo $ECHO_N "checking whether ${CXX} accepts -malign-double... $ECHO_C" >&6
12589   if test "${ac_align_double+set}" = set; then
12590    echo $ECHO_N "(cached) $ECHO_C" >&6
12591   else
12592    echo 'void f(){}' > conftest.cpp
12593 < if test -z "`${CXX-c++} -malign-double -c conftest.cpp 2>&1`"; then
12593 > if test -z "`${CXX} -malign-double -c conftest.cpp 2>&1`"; then
12594          ac_align_double=yes
12595   else
12596          ac_align_double=no
# Line 8139 | Line 12611 | fi
12611      # -fstrict-aliasing for gcc-2.95+
12612  
12613  
12614 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -fstrict-aliasing" >&5
12615 < echo $ECHO_N "checking whether ${CXX-c++} accepts -fstrict-aliasing... $ECHO_C" >&6
12614 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -fstrict-aliasing" >&5
12615 > echo $ECHO_N "checking whether ${CXX} accepts -fstrict-aliasing... $ECHO_C" >&6
12616   if test "${ac_fstrict_aliasing+set}" = set; then
12617    echo $ECHO_N "(cached) $ECHO_C" >&6
12618   else
12619    echo 'void f(){}' > conftest.cpp
12620 < if test -z "`${CXX-c++} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12620 > if test -z "`${CXX} -fstrict-aliasing -c conftest.cpp 2>&1`"; then
12621          ac_fstrict_aliasing=yes
12622   else
12623          ac_fstrict_aliasing=no
# Line 8170 | Line 12642 | fi
12642                    case "${host_cpu}" in
12643            i586*)
12644  
12645 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentium" >&5
12646 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentium... $ECHO_C" >&6
12645 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentium" >&5
12646 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentium... $ECHO_C" >&6
12647   if test "${ac_cpu_pentium+set}" = set; then
12648    echo $ECHO_N "(cached) $ECHO_C" >&6
12649   else
12650    echo 'void f(){}' > conftest.cpp
12651 < if test -z "`${CXX-c++} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12651 > if test -z "`${CXX} -mcpu=pentium -c conftest.cpp 2>&1`"; then
12652          ac_cpu_pentium=yes
12653   else
12654          ac_cpu_pentium=no
# Line 8193 | Line 12665 | else
12665          :
12666  
12667  
12668 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentium" >&5
12669 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentium... $ECHO_C" >&6
12668 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentium" >&5
12669 > echo $ECHO_N "checking whether ${CXX} accepts -mpentium... $ECHO_C" >&6
12670   if test "${ac_pentium+set}" = set; then
12671    echo $ECHO_N "(cached) $ECHO_C" >&6
12672   else
12673    echo 'void f(){}' > conftest.cpp
12674 < if test -z "`${CXX-c++} -mpentium -c conftest.cpp 2>&1`"; then
12674 > if test -z "`${CXX} -mpentium -c conftest.cpp 2>&1`"; then
12675          ac_pentium=yes
12676   else
12677          ac_pentium=no
# Line 8222 | Line 12694 | fi
12694                    ;;
12695            i686*)
12696  
12697 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=pentiumpro" >&5
12698 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12697 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=pentiumpro" >&5
12698 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=pentiumpro... $ECHO_C" >&6
12699   if test "${ac_cpu_pentiumpro+set}" = set; then
12700    echo $ECHO_N "(cached) $ECHO_C" >&6
12701   else
12702    echo 'void f(){}' > conftest.cpp
12703 < if test -z "`${CXX-c++} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12703 > if test -z "`${CXX} -mcpu=pentiumpro -c conftest.cpp 2>&1`"; then
12704          ac_cpu_pentiumpro=yes
12705   else
12706          ac_cpu_pentiumpro=no
# Line 8245 | Line 12717 | else
12717          :
12718  
12719  
12720 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpentiumpro" >&5
12721 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mpentiumpro... $ECHO_C" >&6
12720 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpentiumpro" >&5
12721 > echo $ECHO_N "checking whether ${CXX} accepts -mpentiumpro... $ECHO_C" >&6
12722   if test "${ac_pentiumpro+set}" = set; then
12723    echo $ECHO_N "(cached) $ECHO_C" >&6
12724   else
12725    echo 'void f(){}' > conftest.cpp
12726 < if test -z "`${CXX-c++} -mpentiumpro -c conftest.cpp 2>&1`"; then
12726 > if test -z "`${CXX} -mpentiumpro -c conftest.cpp 2>&1`"; then
12727          ac_pentiumpro=yes
12728   else
12729          ac_pentiumpro=no
# Line 8278 | Line 12750 | fi
12750                  if test -n "$is60x"; then
12751  
12752  
12753 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=$cputype" >&5
12754 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=$cputype... $ECHO_C" >&6
12753 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=$cputype" >&5
12754 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=$cputype... $ECHO_C" >&6
12755   if test "${ac_m_cpu_60x+set}" = set; then
12756    echo $ECHO_N "(cached) $ECHO_C" >&6
12757   else
12758    echo 'void f(){}' > conftest.cpp
12759 < if test -z "`${CXX-c++} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12759 > if test -z "`${CXX} -mcpu=$cputype -c conftest.cpp 2>&1`"; then
12760          ac_m_cpu_60x=yes
12761   else
12762          ac_m_cpu_60x=no
# Line 8336 | Line 12808 | if test "$ac_cv_prog_gxx_2_95" = yes; then
12808          :
12809  
12810  
12811 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=750" >&5
12812 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=750... $ECHO_C" >&6
12811 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=750" >&5
12812 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=750... $ECHO_C" >&6
12813   if test "${ac_m_cpu_750+set}" = set; then
12814    echo $ECHO_N "(cached) $ECHO_C" >&6
12815   else
12816    echo 'void f(){}' > conftest.cpp
12817 < if test -z "`${CXX-c++} -mcpu=750 -c conftest.cpp 2>&1`"; then
12817 > if test -z "`${CXX} -mcpu=750 -c conftest.cpp 2>&1`"; then
12818          ac_m_cpu_750=yes
12819   else
12820          ac_m_cpu_750=no
# Line 8369 | Line 12841 | fi
12841                  if test -z "$CPU_FLAGS"; then
12842  
12843  
12844 < echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
12845 < echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
12844 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mcpu=powerpc" >&5
12845 > echo $ECHO_N "checking whether ${CXX} accepts -mcpu=powerpc... $ECHO_C" >&6
12846   if test "${ac_m_cpu_powerpc+set}" = set; then
12847    echo $ECHO_N "(cached) $ECHO_C" >&6
12848   else
12849    echo 'void f(){}' > conftest.cpp
12850 < if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12850 > if test -z "`${CXX} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
12851          ac_m_cpu_powerpc=yes
12852   else
12853          ac_m_cpu_powerpc=no
# Line 8390 | Line 12862 | else
12862          CPU_FLAGS=-mcpu=powerpc
12863   else
12864          :
8393 –
8394 – fi
8395 –
8396 –                fi
8397 –                if test -z "$CPU_FLAGS"; then
8398 –
8399 –
8400 – echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
8401 – echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
8402 – if test "${ac_m_powerpc+set}" = set; then
8403 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8404 – else
8405 –  echo 'void f(){}' > conftest.cpp
8406 – if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
8407 –        ac_m_powerpc=yes
8408 – else
8409 –        ac_m_powerpc=no
8410 – fi
8411 – rm -f conftest*
8412 –
8413 – fi
8414 – echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
8415 – echo "${ECHO_T}$ac_m_powerpc" >&6
8416 – if test "$ac_m_powerpc" = yes; then
8417 –        :
8418 –        CPU_FLAGS=-mpowerpc
8419 – else
8420 –        :
8421 –
8422 – fi
8423 –
8424 –                fi
8425 –          esac
8426 –  fi
8427 –
8428 –  if test -n "$CPU_FLAGS"; then
8429 –        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
8430 –  fi
8431 –
8432 –  if test -z "$CXXFLAGS"; then
8433 –        echo ""
8434 –        echo "**********************************************************"
8435 –        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
8436 –        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
8437 –        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
8438 –        echo "**********************************************************"
8439 –        echo ""
8440 –        CXXFLAGS="-O3"
8441 –  fi
8442 –
8443 –
8444 –
8445 – echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
8446 – echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
8447 – if test "${ac_guessed_cxxflags+set}" = set; then
8448 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8449 – else
8450 –  echo 'void f(){}' > conftest.cpp
8451 – if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
8452 –        ac_guessed_cxxflags=yes
8453 – else
8454 –        ac_guessed_cxxflags=no
8455 – fi
8456 – rm -f conftest*
8457 –
8458 – fi
8459 – echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
8460 – echo "${ECHO_T}$ac_guessed_cxxflags" >&6
8461 – if test "$ac_guessed_cxxflags" = yes; then
8462 –        :
8463 –
8464 – else
8465 –        :
8466 –
8467 –        echo ""
8468 –        echo "**********************************************************"
8469 –        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
8470 –        echo "* your compiler.                                         *"
8471 –        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
8472 –        echo "**********************************************************"
8473 –        echo ""
8474 –        CXXFLAGS=""
8475 –
8476 – fi
8477 –
8478 –
8479 – fi
8480 –
8481 –
8482 –
8483 –
8484 –
8485 – # Try to determine "good" native compiler flags if none specified on command
8486 – # line
8487 –
8488 – if test x"$F90FLAGS" = x ; then
8489 –  F90FLAGS=""
8490 –  case "${host_cpu}-${host_os}" in
8491 –
8492 –  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
8493 –                    F90FLAGS="-O"
8494 –                fi;;
8495 –   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
8496 –                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
8497 –                fi;;
8498 –   powerpc*-aix*)
8499 –        if test "$F90" = f90 -o "$F90" = xlf90; then
8500 –                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
8501 –                echo "*******************************************************"
8502 –                echo "*  You have AIX on an unknown powerpc system.  It is  *"
8503 –                echo "*  recommended that you use                           *"
8504 –                echo "*                                                     *"
8505 –                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
8506 –                echo "*                                 ^^^                 *"
8507 –                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
8508 –                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
8509 –                echo "*******************************************************"
8510 –        fi;;
8511 –   *darwin*)
8512 –        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
8513 –                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
8514 –        fi;;
8515 –  esac
8516 –
8517 –  if test -n "$CPU_FLAGS"; then
8518 –        F90FLAGS="$F90FLAGS $CPU_FLAGS"
8519 –  fi
8520 –
8521 –  if test -z "$F90FLAGS"; then
8522 –        echo ""
8523 –        echo "**********************************************************"
8524 –        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
8525 –        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8526 –        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
8527 –        echo "**********************************************************"
8528 –        echo ""
8529 –        F90FLAGS="-O3"
8530 –  fi
8531 –
8532 –
8533 – echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
8534 – echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
8535 – if test "${ac_guessed_f90flags+set}" = set; then
8536 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8537 – else
8538 –
8539 –
8540 –
8541 – ac_ext=f90
8542 – ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
8543 – ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8544 – ac_compiler_gnu=$ac_cv_f90_compiler_gnu
8545 –
8546 – echo 'program main' > conftest.$ac_ext
8547 – echo 'end program main' >> conftest.$ac_ext
8548 – ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
8549 – if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8550 –  (eval $ac_compile) 2>&5
8551 –  ac_status=$?
8552 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8553 –  (exit $ac_status); }; then
8554 –        ac_guessed_f90flags=yes
8555 – else
8556 –        ac_guessed_f90flags=no
8557 – fi
8558 – rm -f conftest*
8559 – ac_ext=c
8560 – ac_cpp='$CPP $CPPFLAGS'
8561 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8562 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8563 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
8564 –
8565 –
8566 – fi
8567 – echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
8568 – echo "${ECHO_T}$ac_guessed_f90flags" >&6
8569 – if test "$ac_guessed_f90flags" = yes; then
8570 –        :
8571 –
8572 – else
8573 –        :
8574 –
8575 –        echo ""
8576 –        echo "**********************************************************"
8577 –        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
8578 –        echo "* your compiler.                                         *"
8579 –        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
8580 –        echo "**********************************************************"
8581 –        echo ""
8582 –        F90FLAGS=""
8583 –
8584 – fi
8585 –
8586 –
8587 – fi
8588 –
8589 –     ;;
8590 – esac
8591 –
8592 – # Find a good install program.  We prefer a C program (faster),
8593 – # so one script is as good as another.  But avoid the broken or
8594 – # incompatible versions:
8595 – # SysV /etc/install, /usr/sbin/install
8596 – # SunOS /usr/etc/install
8597 – # IRIX /sbin/install
8598 – # AIX /bin/install
8599 – # AmigaOS /C/install, which installs bootblocks on floppy discs
8600 – # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
8601 – # AFS /usr/afsws/bin/install, which mishandles nonexistent args
8602 – # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
8603 – # OS/2's system install, which has a completely different semantic
8604 – # ./install, which can be erroneously created by make from ./install.sh.
8605 – echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
8606 – echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
8607 – if test -z "$INSTALL"; then
8608 – if test "${ac_cv_path_install+set}" = set; then
8609 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8610 – else
8611 –  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8612 – for as_dir in $PATH
8613 – do
8614 –  IFS=$as_save_IFS
8615 –  test -z "$as_dir" && as_dir=.
8616 –  # Account for people who put trailing slashes in PATH elements.
8617 – case $as_dir/ in
8618 –  ./ | .// | /cC/* | \
8619 –  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
8620 –  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
8621 –  /usr/ucb/* ) ;;
8622 –  *)
8623 –    # OSF1 and SCO ODT 3.0 have their own names for install.
8624 –    # Don't use installbsd from OSF since it installs stuff as root
8625 –    # by default.
8626 –    for ac_prog in ginstall scoinst install; do
8627 –      for ac_exec_ext in '' $ac_executable_extensions; do
8628 –        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
8629 –          if test $ac_prog = install &&
8630 –            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8631 –            # AIX install.  It has an incompatible calling convention.
8632 –            :
8633 –          elif test $ac_prog = install &&
8634 –            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
8635 –            # program-specific install script used by HP pwplus--don't use.
8636 –            :
8637 –          else
8638 –            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
8639 –            break 3
8640 –          fi
8641 –        fi
8642 –      done
8643 –    done
8644 –    ;;
8645 – esac
8646 – done
8647 –
8648 –
8649 – fi
8650 –  if test "${ac_cv_path_install+set}" = set; then
8651 –    INSTALL=$ac_cv_path_install
8652 –  else
8653 –    # As a last resort, use the slow shell script.  We don't cache a
8654 –    # path for INSTALL within a source directory, because that will
8655 –    # break other packages using the cache if that directory is
8656 –    # removed, or if the path is relative.
8657 –    INSTALL=$ac_install_sh
8658 –  fi
8659 – fi
8660 – echo "$as_me:$LINENO: result: $INSTALL" >&5
8661 – echo "${ECHO_T}$INSTALL" >&6
8662 –
8663 – # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
8664 – # It thinks the first close brace ends the variable substitution.
8665 – test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
8666 –
8667 – test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
8668 –
8669 – test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
8670 –
8671 – echo "$as_me:$LINENO: checking whether ln -s works" >&5
8672 – echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
8673 – LN_S=$as_ln_s
8674 – if test "$LN_S" = "ln -s"; then
8675 –  echo "$as_me:$LINENO: result: yes" >&5
8676 – echo "${ECHO_T}yes" >&6
8677 – else
8678 –  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
8679 – echo "${ECHO_T}no, using $LN_S" >&6
8680 – fi
8681 –
8682 – echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
8683 – echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
8684 – set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
8685 – if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
8686 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8687 – else
8688 –  cat >conftest.make <<\_ACEOF
8689 – all:
8690 –        @echo 'ac_maketemp="$(MAKE)"'
8691 – _ACEOF
8692 – # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
8693 – eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
8694 – if test -n "$ac_maketemp"; then
8695 –  eval ac_cv_prog_make_${ac_make}_set=yes
8696 – else
8697 –  eval ac_cv_prog_make_${ac_make}_set=no
8698 – fi
8699 – rm -f conftest.make
8700 – fi
8701 – if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
8702 –  echo "$as_me:$LINENO: result: yes" >&5
8703 – echo "${ECHO_T}yes" >&6
8704 –  SET_MAKE=
8705 – else
8706 –  echo "$as_me:$LINENO: result: no" >&5
8707 – echo "${ECHO_T}no" >&6
8708 –  SET_MAKE="MAKE=${MAKE-make}"
8709 – fi
8710 –
8711 – if test -n "$ac_tool_prefix"; then
8712 –  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
8713 – set dummy ${ac_tool_prefix}ranlib; ac_word=$2
8714 – echo "$as_me:$LINENO: checking for $ac_word" >&5
8715 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8716 – if test "${ac_cv_prog_RANLIB+set}" = set; then
8717 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8718 – else
8719 –  if test -n "$RANLIB"; then
8720 –  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8721 – else
8722 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8723 – for as_dir in $PATH
8724 – do
8725 –  IFS=$as_save_IFS
8726 –  test -z "$as_dir" && as_dir=.
8727 –  for ac_exec_ext in '' $ac_executable_extensions; do
8728 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8729 –    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
8730 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8731 –    break 2
8732 –  fi
8733 – done
8734 – done
8735 –
8736 – fi
8737 – fi
8738 – RANLIB=$ac_cv_prog_RANLIB
8739 – if test -n "$RANLIB"; then
8740 –  echo "$as_me:$LINENO: result: $RANLIB" >&5
8741 – echo "${ECHO_T}$RANLIB" >&6
8742 – else
8743 –  echo "$as_me:$LINENO: result: no" >&5
8744 – echo "${ECHO_T}no" >&6
8745 – fi
8746 –
8747 – fi
8748 – if test -z "$ac_cv_prog_RANLIB"; then
8749 –  ac_ct_RANLIB=$RANLIB
8750 –  # Extract the first word of "ranlib", so it can be a program name with args.
8751 – set dummy ranlib; ac_word=$2
8752 – echo "$as_me:$LINENO: checking for $ac_word" >&5
8753 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8754 – if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
8755 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8756 – else
8757 –  if test -n "$ac_ct_RANLIB"; then
8758 –  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
8759 – else
8760 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8761 – for as_dir in $PATH
8762 – do
8763 –  IFS=$as_save_IFS
8764 –  test -z "$as_dir" && as_dir=.
8765 –  for ac_exec_ext in '' $ac_executable_extensions; do
8766 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8767 –    ac_cv_prog_ac_ct_RANLIB="ranlib"
8768 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8769 –    break 2
8770 –  fi
8771 – done
8772 – done
8773 –
8774 –  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
8775 – fi
8776 – fi
8777 – ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
8778 – if test -n "$ac_ct_RANLIB"; then
8779 –  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
8780 – echo "${ECHO_T}$ac_ct_RANLIB" >&6
8781 – else
8782 –  echo "$as_me:$LINENO: result: no" >&5
8783 – echo "${ECHO_T}no" >&6
8784 – fi
8785 –
8786 –  RANLIB=$ac_ct_RANLIB
8787 – else
8788 –  RANLIB="$ac_cv_prog_RANLIB"
8789 – fi
8790 –
8791 – for ac_prog in 'bison -y' byacc
8792 – do
8793 –  # Extract the first word of "$ac_prog", so it can be a program name with args.
8794 – set dummy $ac_prog; ac_word=$2
8795 – echo "$as_me:$LINENO: checking for $ac_word" >&5
8796 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8797 – if test "${ac_cv_prog_YACC+set}" = set; then
8798 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8799 – else
8800 –  if test -n "$YACC"; then
8801 –  ac_cv_prog_YACC="$YACC" # Let the user override the test.
8802 – else
8803 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8804 – for as_dir in $PATH
8805 – do
8806 –  IFS=$as_save_IFS
8807 –  test -z "$as_dir" && as_dir=.
8808 –  for ac_exec_ext in '' $ac_executable_extensions; do
8809 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8810 –    ac_cv_prog_YACC="$ac_prog"
8811 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8812 –    break 2
8813 –  fi
8814 – done
8815 – done
8816 –
8817 – fi
8818 – fi
8819 – YACC=$ac_cv_prog_YACC
8820 – if test -n "$YACC"; then
8821 –  echo "$as_me:$LINENO: result: $YACC" >&5
8822 – echo "${ECHO_T}$YACC" >&6
8823 – else
8824 –  echo "$as_me:$LINENO: result: no" >&5
8825 – echo "${ECHO_T}no" >&6
8826 – fi
8827 –
8828 –  test -n "$YACC" && break
8829 – done
8830 – test -n "$YACC" || YACC="yacc"
8831 –
8832 – for ac_prog in flex lex
8833 – do
8834 –  # Extract the first word of "$ac_prog", so it can be a program name with args.
8835 – set dummy $ac_prog; ac_word=$2
8836 – echo "$as_me:$LINENO: checking for $ac_word" >&5
8837 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8838 – if test "${ac_cv_prog_LEX+set}" = set; then
8839 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8840 – else
8841 –  if test -n "$LEX"; then
8842 –  ac_cv_prog_LEX="$LEX" # Let the user override the test.
8843 – else
8844 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8845 – for as_dir in $PATH
8846 – do
8847 –  IFS=$as_save_IFS
8848 –  test -z "$as_dir" && as_dir=.
8849 –  for ac_exec_ext in '' $ac_executable_extensions; do
8850 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8851 –    ac_cv_prog_LEX="$ac_prog"
8852 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8853 –    break 2
8854 –  fi
8855 – done
8856 – done
8857 –
8858 – fi
8859 – fi
8860 – LEX=$ac_cv_prog_LEX
8861 – if test -n "$LEX"; then
8862 –  echo "$as_me:$LINENO: result: $LEX" >&5
8863 – echo "${ECHO_T}$LEX" >&6
8864 – else
8865 –  echo "$as_me:$LINENO: result: no" >&5
8866 – echo "${ECHO_T}no" >&6
8867 – fi
8868 –
8869 –  test -n "$LEX" && break
8870 – done
8871 – test -n "$LEX" || LEX=":"
8872 –
8873 – if test -z "$LEXLIB"
8874 – then
8875 –  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
8876 – echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
8877 – if test "${ac_cv_lib_fl_yywrap+set}" = set; then
8878 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8879 – else
8880 –  ac_check_lib_save_LIBS=$LIBS
8881 – LIBS="-lfl  $LIBS"
8882 – cat >conftest.$ac_ext <<_ACEOF
8883 – /* confdefs.h.  */
8884 – _ACEOF
8885 – cat confdefs.h >>conftest.$ac_ext
8886 – cat >>conftest.$ac_ext <<_ACEOF
8887 – /* end confdefs.h.  */
8888 –
8889 – /* Override any gcc2 internal prototype to avoid an error.  */
8890 – #ifdef __cplusplus
8891 – extern "C"
8892 – #endif
8893 – /* We use char because int might match the return type of a gcc2
8894 –   builtin and then its argument prototype would still apply.  */
8895 – char yywrap ();
8896 – int
8897 – main ()
8898 – {
8899 – yywrap ();
8900 –  ;
8901 –  return 0;
8902 – }
8903 – _ACEOF
8904 – rm -f conftest.$ac_objext conftest$ac_exeext
8905 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8906 –  (eval $ac_link) 2>conftest.er1
8907 –  ac_status=$?
8908 –  grep -v '^ *+' conftest.er1 >conftest.err
8909 –  rm -f conftest.er1
8910 –  cat conftest.err >&5
8911 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8912 –  (exit $ac_status); } &&
8913 –         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8914 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8915 –  (eval $ac_try) 2>&5
8916 –  ac_status=$?
8917 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8918 –  (exit $ac_status); }; } &&
8919 –         { ac_try='test -s conftest$ac_exeext'
8920 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8921 –  (eval $ac_try) 2>&5
8922 –  ac_status=$?
8923 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8924 –  (exit $ac_status); }; }; then
8925 –  ac_cv_lib_fl_yywrap=yes
8926 – else
8927 –  echo "$as_me: failed program was:" >&5
8928 – sed 's/^/| /' conftest.$ac_ext >&5
8929 –
8930 – ac_cv_lib_fl_yywrap=no
8931 – fi
8932 – rm -f conftest.err conftest.$ac_objext \
8933 –      conftest$ac_exeext conftest.$ac_ext
8934 – LIBS=$ac_check_lib_save_LIBS
8935 – fi
8936 – echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
8937 – echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
8938 – if test $ac_cv_lib_fl_yywrap = yes; then
8939 –  LEXLIB="-lfl"
8940 – else
8941 –  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
8942 – echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
8943 – if test "${ac_cv_lib_l_yywrap+set}" = set; then
8944 –  echo $ECHO_N "(cached) $ECHO_C" >&6
8945 – else
8946 –  ac_check_lib_save_LIBS=$LIBS
8947 – LIBS="-ll  $LIBS"
8948 – cat >conftest.$ac_ext <<_ACEOF
8949 – /* confdefs.h.  */
8950 – _ACEOF
8951 – cat confdefs.h >>conftest.$ac_ext
8952 – cat >>conftest.$ac_ext <<_ACEOF
8953 – /* end confdefs.h.  */
8954 –
8955 – /* Override any gcc2 internal prototype to avoid an error.  */
8956 – #ifdef __cplusplus
8957 – extern "C"
8958 – #endif
8959 – /* We use char because int might match the return type of a gcc2
8960 –   builtin and then its argument prototype would still apply.  */
8961 – char yywrap ();
8962 – int
8963 – main ()
8964 – {
8965 – yywrap ();
8966 –  ;
8967 –  return 0;
8968 – }
8969 – _ACEOF
8970 – rm -f conftest.$ac_objext conftest$ac_exeext
8971 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8972 –  (eval $ac_link) 2>conftest.er1
8973 –  ac_status=$?
8974 –  grep -v '^ *+' conftest.er1 >conftest.err
8975 –  rm -f conftest.er1
8976 –  cat conftest.err >&5
8977 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8978 –  (exit $ac_status); } &&
8979 –         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
8980 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8981 –  (eval $ac_try) 2>&5
8982 –  ac_status=$?
8983 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8984 –  (exit $ac_status); }; } &&
8985 –         { ac_try='test -s conftest$ac_exeext'
8986 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8987 –  (eval $ac_try) 2>&5
8988 –  ac_status=$?
8989 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8990 –  (exit $ac_status); }; }; then
8991 –  ac_cv_lib_l_yywrap=yes
8992 – else
8993 –  echo "$as_me: failed program was:" >&5
8994 – sed 's/^/| /' conftest.$ac_ext >&5
8995 –
8996 – ac_cv_lib_l_yywrap=no
8997 – fi
8998 – rm -f conftest.err conftest.$ac_objext \
8999 –      conftest$ac_exeext conftest.$ac_ext
9000 – LIBS=$ac_check_lib_save_LIBS
9001 – fi
9002 – echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
9003 – echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
9004 – if test $ac_cv_lib_l_yywrap = yes; then
9005 –  LEXLIB="-ll"
9006 – fi
9007 –
9008 – fi
9009 –
9010 – fi
9011 –
9012 – if test "x$LEX" != "x:"; then
9013 –  echo "$as_me:$LINENO: checking lex output file root" >&5
9014 – echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
9015 – if test "${ac_cv_prog_lex_root+set}" = set; then
9016 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9017 – else
9018 –  # The minimal lex program is just a single line: %%.  But some broken lexes
9019 – # (Solaris, I think it was) want two %% lines, so accommodate them.
9020 – cat >conftest.l <<_ACEOF
9021 – %%
9022 – %%
9023 – _ACEOF
9024 – { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
9025 –  (eval $LEX conftest.l) 2>&5
9026 –  ac_status=$?
9027 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9028 –  (exit $ac_status); }
9029 – if test -f lex.yy.c; then
9030 –  ac_cv_prog_lex_root=lex.yy
9031 – elif test -f lexyy.c; then
9032 –  ac_cv_prog_lex_root=lexyy
9033 – else
9034 –  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
9035 – echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
9036 –   { (exit 1); exit 1; }; }
9037 – fi
9038 – fi
9039 – echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
9040 – echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
9041 – rm -f conftest.l
9042 – LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
9043 –
9044 – echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
9045 – echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
9046 – if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
9047 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9048 – else
9049 –  # POSIX says lex can declare yytext either as a pointer or an array; the
9050 – # default is implementation-dependent. Figure out which it is, since
9051 – # not all implementations provide the %pointer and %array declarations.
9052 – ac_cv_prog_lex_yytext_pointer=no
9053 – echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
9054 – ac_save_LIBS=$LIBS
9055 – LIBS="$LIBS $LEXLIB"
9056 – cat >conftest.$ac_ext <<_ACEOF
9057 – `cat $LEX_OUTPUT_ROOT.c`
9058 – _ACEOF
9059 – rm -f conftest.$ac_objext conftest$ac_exeext
9060 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9061 –  (eval $ac_link) 2>conftest.er1
9062 –  ac_status=$?
9063 –  grep -v '^ *+' conftest.er1 >conftest.err
9064 –  rm -f conftest.er1
9065 –  cat conftest.err >&5
9066 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9067 –  (exit $ac_status); } &&
9068 –         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
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); }; } &&
9074 –         { ac_try='test -s conftest$ac_exeext'
9075 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9076 –  (eval $ac_try) 2>&5
9077 –  ac_status=$?
9078 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9079 –  (exit $ac_status); }; }; then
9080 –  ac_cv_prog_lex_yytext_pointer=yes
9081 – else
9082 –  echo "$as_me: failed program was:" >&5
9083 – sed 's/^/| /' conftest.$ac_ext >&5
9084 –
9085 – fi
9086 – rm -f conftest.err conftest.$ac_objext \
9087 –      conftest$ac_exeext conftest.$ac_ext
9088 – LIBS=$ac_save_LIBS
9089 – rm -f "${LEX_OUTPUT_ROOT}.c"
9090 –
9091 – fi
9092 – echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
9093 – echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
9094 – if test $ac_cv_prog_lex_yytext_pointer = yes; then
9095 –
9096 – cat >>confdefs.h <<\_ACEOF
9097 – #define YYTEXT_POINTER 1
9098 – _ACEOF
9099 –
9100 – fi
9101 –
9102 – fi
9103 –
9104 –   # Extract the first word of "perl", so it can be a program name with args.
9105 – set dummy perl; ac_word=$2
9106 – echo "$as_me:$LINENO: checking for $ac_word" >&5
9107 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9108 – if test "${ac_cv_path_PERLINTERP+set}" = set; then
9109 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9110 – else
9111 –  case $PERLINTERP in
9112 –  [\\/]* | ?:[\\/]*)
9113 –  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
9114 –  ;;
9115 –  *)
9116 –  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9117 – for as_dir in $PATH
9118 – do
9119 –  IFS=$as_save_IFS
9120 –  test -z "$as_dir" && as_dir=.
9121 –  for ac_exec_ext in '' $ac_executable_extensions; do
9122 –  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9123 –    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
9124 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9125 –    break 2
9126 –  fi
9127 – done
9128 – done
9129 –
9130 –  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
9131 –  ;;
9132 – esac
9133 – fi
9134 – PERLINTERP=$ac_cv_path_PERLINTERP
9135 –
9136 – if test -n "$PERLINTERP"; then
9137 –  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
9138 – echo "${ECHO_T}$PERLINTERP" >&6
9139 – else
9140 –  echo "$as_me:$LINENO: result: no" >&5
9141 – echo "${ECHO_T}no" >&6
9142 – fi
9143 –
9144 –   ac_cv_path_perlinterp="$PERLINTERP"
9145 –   _sHpB='#!'
9146 –
9147 –
9148 – # Check whether --with-perl-shebang or --without-perl-shebang was given.
9149 – if test "${with_perl_shebang+set}" = set; then
9150 –  withval="$with_perl_shebang"
9151 –  opt_perl_shebang="$withval"
9152 – else
9153 –                opt_perl_shebang="not_set"
9154 – fi;
9155 –   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
9156 – echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
9157 – if test "${ax_cv_opt_perl_shebang+set}" = set; then
9158 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9159 – else
9160 –   case "$opt_perl_shebang" in
9161 –                      not_set  ) ax_cv_opt_perl_shebang=''
9162 –                               ;;
9163 –                         *     )
9164 –        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
9165 –                    esac
9166 –
9167 – fi
9168 – echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
9169 – echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
9170 –   if test "A$ax_cv_opt_perl_shebang" != "A"
9171 –     then
9172 –       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
9173 –       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9174 –              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
9175 – echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
12865  
9177 – # Automatic detection of sharpbang formula starts here
9178 –     else
9179 –   _somian_shbangperl=`$PERLINTERP -V:startperl`
9180 –   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
9181 –   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
9182 – echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
9183 – if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
9184 –  echo $ECHO_N "(cached) $ECHO_C" >&6
9185 – else
9186 –  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
9187 –        if test "x$_somian_kspb_perl" == x
9188 –          then _somian_ksbp_warn_empty='durnit'
9189 –          else
9190 –          case "A$_somian_kspb_perl" in
9191 –                 A#!*perl* )
9192 –           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
9193 –                        ;;
9194 –                     A*    )  _somian_ksbp_warn_defau='trouble'
9195 –                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
9196 –          esac
9197 –        fi
9198 –
12866   fi
9200 – echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
9201 – echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
9202 – # The above prints Checking ... result message to user.
9203 –   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
12867  
12868 <    if test A${_somian_ksbp_warn_empty+set} == Aset
12869 <      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
9207 < echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
9208 <    fi
9209 < # Inform user after printing result value
9210 <    if test A${_somian_ksbp_warn_defau+set} == Aset
9211 <      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
9212 < echo "$as_me: Maybe Not good -" >&6;}
9213 <           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
9214 < echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
9215 <      else { echo "$as_me:$LINENO: OK Good result - " >&5
9216 < echo "$as_me: OK Good result - " >&6;}
9217 <           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
9218 < echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
9219 <    fi
9220 <  fi
12868 >                fi
12869 >                if test -z "$CPU_FLAGS"; then
12870  
12871 < # Extract the first word of "ar", so it can be a program name with args.
12872 < set dummy ar; ac_word=$2
12873 < echo "$as_me:$LINENO: checking for $ac_word" >&5
12874 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9226 < if test "${ac_cv_prog_AR+set}" = set; then
12871 >
12872 > echo "$as_me:$LINENO: checking whether ${CXX} accepts -mpowerpc" >&5
12873 > echo $ECHO_N "checking whether ${CXX} accepts -mpowerpc... $ECHO_C" >&6
12874 > if test "${ac_m_powerpc+set}" = set; then
12875    echo $ECHO_N "(cached) $ECHO_C" >&6
12876   else
12877 <  if test -n "$AR"; then
12878 <  ac_cv_prog_AR="$AR" # Let the user override the test.
12877 >  echo 'void f(){}' > conftest.cpp
12878 > if test -z "`${CXX} -mpowerpc -c conftest.cpp 2>&1`"; then
12879 >        ac_m_powerpc=yes
12880   else
12881 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12882 < for as_dir in $PATH
12883 < do
9235 <  IFS=$as_save_IFS
9236 <  test -z "$as_dir" && as_dir=.
9237 <  for ac_exec_ext in '' $ac_executable_extensions; do
9238 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9239 <    ac_cv_prog_AR="ar"
9240 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9241 <    break 2
9242 <  fi
9243 < done
9244 < done
12881 >        ac_m_powerpc=no
12882 > fi
12883 > rm -f conftest*
12884  
9246 –  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
12885   fi
12886 < fi
12887 < AR=$ac_cv_prog_AR
12888 < if test -n "$AR"; then
12889 <  echo "$as_me:$LINENO: result: $AR" >&5
12890 < echo "${ECHO_T}$AR" >&6
12886 > echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
12887 > echo "${ECHO_T}$ac_m_powerpc" >&6
12888 > if test "$ac_m_powerpc" = yes; then
12889 >        :
12890 >        CPU_FLAGS=-mpowerpc
12891   else
12892 <  echo "$as_me:$LINENO: result: no" >&5
12893 < echo "${ECHO_T}no" >&6
12892 >        :
12893 >
12894   fi
12895  
12896 < if test "$AR" = "NONE"; then
12897 <  { { echo "$as_me:$LINENO: error: --> Can't find \`ar'!" >&5
12898 < echo "$as_me: error: --> Can't find \`ar'!" >&2;}
9261 <   { (exit 1); exit 1; }; }
9262 <  cat >confcache <<\_ACEOF
9263 < # This file is a shell script that caches the results of configure
9264 < # tests run on this system so they can be shared between configure
9265 < # scripts and configure runs, see configure's option --config-cache.
9266 < # It is not useful on other systems.  If it contains results you don't
9267 < # want to keep, you may remove or edit it.
9268 < #
9269 < # config.status only pays attention to the cache file if you give it
9270 < # the --recheck option to rerun configure.
9271 < #
9272 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
9273 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
9274 < # following values.
12896 >                fi
12897 >          esac
12898 >  fi
12899  
12900 < _ACEOF
12900 >  if test -n "$CPU_FLAGS"; then
12901 >        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
12902 >  fi
12903  
12904 < # The following way of writing the cache mishandles newlines in values,
12905 < # but we know of no workaround that is simple, portable, and efficient.
12906 < # So, don't put newlines in cache variables' values.
12907 < # Ultrix sh set writes to stderr and can't be redirected directly,
12908 < # and sets the high bit in the cache file unless we assign to the vars.
12909 < {
12910 <  (set) 2>&1 |
12911 <    case `(ac_space=' '; set | grep ac_space) 2>&1` in
12912 <    *ac_space=\ *)
9287 <      # `set' does not quote correctly, so add quotes (double-quote
9288 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
9289 <      sed -n \
9290 <        "s/'/'\\\\''/g;
9291 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
9292 <      ;;
9293 <    *)
9294 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
9295 <      sed -n \
9296 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
9297 <      ;;
9298 <    esac;
9299 < } |
9300 <  sed '
9301 <     t clear
9302 <     : clear
9303 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
9304 <     t end
9305 <     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
9306 <     : end' >>confcache
9307 < if diff $cache_file confcache >/dev/null 2>&1; then :; else
9308 <  if test -w $cache_file; then
9309 <    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
9310 <    cat confcache >$cache_file
9311 <  else
9312 <    echo "not updating unwritable cache $cache_file"
12904 >  if test -z "$CXXFLAGS"; then
12905 >        echo ""
12906 >        echo "**********************************************************"
12907 >        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
12908 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12909 >        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
12910 >        echo "**********************************************************"
12911 >        echo ""
12912 >        CXXFLAGS="-O3"
12913    fi
9314 – fi
9315 – rm -f confcache
9316 –  exit 1
9317 – fi
12914  
12915 < # Extract the first word of "ps", so it can be a program name with args.
12916 < set dummy ps; ac_word=$2
12917 < echo "$as_me:$LINENO: checking for $ac_word" >&5
12918 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
12919 < if test "${ac_cv_path_PS+set}" = set; then
12915 >
12916 >
12917 > echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12918 > echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6
12919 > if test "${ac_guessed_cxxflags+set}" = set; then
12920    echo $ECHO_N "(cached) $ECHO_C" >&6
12921   else
12922 <  case $PS in
12923 <  [\\/]* | ?:[\\/]*)
12924 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
12925 <  ;;
12926 <  *)
9331 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9332 < for as_dir in $PATH
9333 < do
9334 <  IFS=$as_save_IFS
9335 <  test -z "$as_dir" && as_dir=.
9336 <  for ac_exec_ext in '' $ac_executable_extensions; do
9337 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9338 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
9339 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9340 <    break 2
9341 <  fi
9342 < done
9343 < done
9344 <
9345 <  ;;
9346 < esac
12922 >  echo 'void f(){}' > conftest.cpp
12923 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12924 >        ac_guessed_cxxflags=yes
12925 > else
12926 >        ac_guessed_cxxflags=no
12927   fi
12928 < PS=$ac_cv_path_PS
12928 > rm -f conftest*
12929  
9350 – if test -n "$PS"; then
9351 –  echo "$as_me:$LINENO: result: $PS" >&5
9352 – echo "${ECHO_T}$PS" >&6
9353 – else
9354 –  echo "$as_me:$LINENO: result: no" >&5
9355 – echo "${ECHO_T}no" >&6
12930   fi
12931 + echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12932 + echo "${ECHO_T}$ac_guessed_cxxflags" >&6
12933 + if test "$ac_guessed_cxxflags" = yes; then
12934 +        :
12935  
9358 – echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
9359 – echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
9360 – if test "${ac_cv_prog_ps_syntax+set}" = set; then
9361 –  echo $ECHO_N "(cached) $ECHO_C" >&6
12936   else
12937 +        :
12938  
12939 <        if $PS ax -o rss > /dev/null 2>&1; then
12940 <                ac_cv_prog_ps_ax=yes
12941 <        else
12942 <                ac_cv_prog_ps_ax=no
12943 <        fi
12944 <        if $PS -ef -o rss > /dev/null 2>&1; then
12945 <                ac_cv_prog_ps_ef=yes
12946 <        else
9372 <                ac_cv_prog_ps_ef=no
9373 <        fi
9374 <        if test "$ac_cv_prog_ps_ax" = yes; then
9375 <                ac_cv_prog_ps_syntax=BSD
9376 <        else
9377 <                if test "$ac_cv_prog_ps_ef" = yes; then
9378 <                        ac_cv_prog_ps_syntax=POSIX
9379 <                else
9380 <                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
9381 < echo "$as_me: error: Could not determine ps syntax" >&2;}
9382 <   { (exit 1); exit 1; }; }
9383 <                fi
9384 <        fi
12939 >        echo ""
12940 >        echo "**********************************************************"
12941 >        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
12942 >        echo "* your compiler.                                         *"
12943 >        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12944 >        echo "**********************************************************"
12945 >        echo ""
12946 >        CXXFLAGS=""
12947  
12948   fi
9387 – echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
9388 – echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
12949  
12950  
12951 < cat >>confdefs.h <<_ACEOF
9392 < #define PSCOMMAND $PS
9393 < _ACEOF
12951 > fi
12952  
12953 +     ;;
12954 + esac
12955  
12956 +
12957   cat >>confdefs.h <<\_ACEOF
12958   #define OBAPI
12959   _ACEOF
12960  
12961  
12962  
9402 – if test "$ac_cv_prog_ps_syntax" = BSD; then
9403 –  cat >>confdefs.h <<\_ACEOF
9404 – #define PSTYPE_IS_BSD 1
9405 – _ACEOF
12963  
9407 – else
9408 –   if test "$ac_cv_prog_ps_syntax" = POSIX; then
9409 –       cat >>confdefs.h <<\_ACEOF
9410 – #define PSTYPE_IS_POSIX 1
9411 – _ACEOF
9412 –
9413 –   else
9414 –       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
9415 – echo "$as_me: error: Unknown ps syntax type!" >&2;}
9416 –   { (exit 1); exit 1; }; }
9417 –   fi
9418 – fi
9419 –
9420 –
12964   # Check whether --with-mpi or --without-mpi was given.
12965   if test "${with_mpi+set}" = set; then
12966    withval="$with_mpi"
# Line 9443 | Line 12986 | MPI_INC_DIR="$MPI/include"
12986  
12987  
12988  
12989 + ac_ext=c
12990 + ac_cpp='$CPP $CPPFLAGS'
12991 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12992 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12993 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
12994 +
12995   echo "$as_me:$LINENO: checking for mpi.h" >&5
12996   echo $ECHO_N "checking for mpi.h... $ECHO_C" >&6
12997   have_mpi_h=0
12998   rm -f conftest*
12999 < echo '#include <mpi.h>' > conftest.cc
13000 < if ${CXX} -I${MPI_INC_DIR} -c conftest.cc 2>&1 ; then
12999 > echo '#include <mpi.h>' > conftest.c
13000 > if ${CC} -I${MPI_INC_DIR} -c conftest.c 2>&1 ; then
13001          echo "$as_me:$LINENO: result: yes" >&5
13002   echo "${ECHO_T}yes" >&6
13003          have_mpi_h=1
# Line 9471 | Line 13020 | echo $ECHO_N "checking whether mpif.h is usable... $EC
13020  
13021   echo "$as_me:$LINENO: checking whether mpif.h is usable" >&5
13022   echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6
13023 +
13024 +
13025 + ac_ext=${FC_SRCEXT-f}
13026 + ac_compile='$FC -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext >&5'
13027 + ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext $LIBS >&5'
13028 + ac_compiler_gnu=$ac_cv_fc_compiler_gnu
13029 +
13030 + ac_save_ext=$ac_ext
13031 + ac_ext=F90
13032 + ac_save_FCFLAGS=$FCFLAGS
13033   have_mpif_h=0
13034   rm -f conftest*
13035 < cat >conftest.f90 <<EOF
13035 > cat >conftest.$ac_ext <<EOF
13036   program main
13037     include 'mpif.h'
13038   end
13039   EOF
13040 < if $F90 -I$MPI_INC_DIR -c conftest.f90 > conftest.out 2>&1 ; then
13040 > if $FC -I$MPI_INC_DIR -c $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext > conftest.out 2>&1 ; then
13041          echo "$as_me:$LINENO: result: yes" >&5
13042   echo "${ECHO_T}yes" >&6
13043          MPI_F90_INC="$MPI_INC_DIR"
# Line 9500 | Line 13059 | fi
13059   _ACEOF
13060  
13061   fi
13062 + FCFLAGS=$ac_save_FCFLAGS
13063 + ac_ext=$ac_save_ext
13064 + ac_ext=c
13065 + ac_cpp='$CPP $CPPFLAGS'
13066 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
13067 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
13068 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
13069  
13070 +
13071   ac_ext=c
13072   ac_cpp='$CPP $CPPFLAGS'
13073   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 9508 | Line 13075 | ac_save_LDFLAGS=$LDFLAGS
13075   ac_compiler_gnu=$ac_cv_c_compiler_gnu
13076  
13077   ac_save_LDFLAGS=$LDFLAGS
13078 < LDFLAGS="${LDFLAGS} -L${MPI_LIB_DIR} "
13078 > LDFLAGS="-L${MPI_LIB_DIR} ${LDFLAGS} "
13079  
13080   if test x = x"$MPI_LIB"; then
13081          echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
# Line 9532 | Line 13099 | char MPI_Init ();
13099   /* We use char because int might match the return type of a gcc2
13100     builtin and then its argument prototype would still apply.  */
13101   char MPI_Init ();
13102 + #ifdef FC_DUMMY_MAIN
13103 + #ifndef FC_DUMMY_MAIN_EQ_F77
13104 + #  ifdef __cplusplus
13105 +     extern "C"
13106 + #  endif
13107 +   int FC_DUMMY_MAIN() { return 1; }
13108 + #endif
13109 + #endif
13110   int
13111   main ()
13112   {
# Line 9549 | Line 13124 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13124    cat conftest.err >&5
13125    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13126    (exit $ac_status); } &&
13127 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13127 >         { ac_try='test -z "$ac_c_werror_flag"
13128 >                         || test ! -s conftest.err'
13129    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13130    (eval $ac_try) 2>&5
13131    ac_status=$?
# Line 9579 | Line 13155 | fi
13155   fi
13156  
13157   fi
13158 + $as_unset ac_cv_lib_mpich_MPI_Init
13159   if test x = x"$MPI_LIB"; then
13160 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13161 < echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13162 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13160 >        echo "$as_me:$LINENO: checking for MPI_Init in -lpmpich" >&5
13161 > echo $ECHO_N "checking for MPI_Init in -lpmpich... $ECHO_C" >&6
13162 > if test "${ac_cv_lib_pmpich_MPI_Init+set}" = set; then
13163    echo $ECHO_N "(cached) $ECHO_C" >&6
13164   else
13165    ac_check_lib_save_LIBS=$LIBS
13166 < LIBS="-lmpi  $LIBS"
13166 > LIBS="-lpmpich -lmpich -lpmpich -lmpich $LIBS"
13167   cat >conftest.$ac_ext <<_ACEOF
13168   /* confdefs.h.  */
13169   _ACEOF
# Line 9601 | Line 13178 | char MPI_Init ();
13178   /* We use char because int might match the return type of a gcc2
13179     builtin and then its argument prototype would still apply.  */
13180   char MPI_Init ();
13181 + #ifdef FC_DUMMY_MAIN
13182 + #ifndef FC_DUMMY_MAIN_EQ_F77
13183 + #  ifdef __cplusplus
13184 +     extern "C"
13185 + #  endif
13186 +   int FC_DUMMY_MAIN() { return 1; }
13187 + #endif
13188 + #endif
13189   int
13190   main ()
13191   {
# Line 9618 | Line 13203 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13203    cat conftest.err >&5
13204    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13205    (exit $ac_status); } &&
13206 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13206 >         { ac_try='test -z "$ac_c_werror_flag"
13207 >                         || test ! -s conftest.err'
13208    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13209    (eval $ac_try) 2>&5
13210    ac_status=$?
# Line 9630 | Line 13216 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13216    ac_status=$?
13217    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13218    (exit $ac_status); }; }; then
13219 <  ac_cv_lib_mpi_MPI_Init=yes
13219 >  ac_cv_lib_pmpich_MPI_Init=yes
13220   else
13221    echo "$as_me: failed program was:" >&5
13222   sed 's/^/| /' conftest.$ac_ext >&5
13223  
13224 < ac_cv_lib_mpi_MPI_Init=no
13224 > ac_cv_lib_pmpich_MPI_Init=no
13225   fi
13226   rm -f conftest.err conftest.$ac_objext \
13227        conftest$ac_exeext conftest.$ac_ext
13228   LIBS=$ac_check_lib_save_LIBS
13229   fi
13230 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13231 < echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13232 < if test $ac_cv_lib_mpi_MPI_Init = yes; then
13233 <  MPI_LIB="-lmpi"
13230 > echo "$as_me:$LINENO: result: $ac_cv_lib_pmpich_MPI_Init" >&5
13231 > echo "${ECHO_T}$ac_cv_lib_pmpich_MPI_Init" >&6
13232 > if test $ac_cv_lib_pmpich_MPI_Init = yes; then
13233 >  MPI_LIB="-lpmpich -lmpich -lpmpich -lmpich"
13234   fi
13235  
13236   fi
9651 – $as_unset ac_cv_lib_mpi_MPI_Init
13237   if test x = x"$MPI_LIB"; then
13238          echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13239   echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
# Line 9656 | Line 13241 | else
13241    echo $ECHO_N "(cached) $ECHO_C" >&6
13242   else
13243    ac_check_lib_save_LIBS=$LIBS
13244 < LIBS="-lmpi "-llam" $LIBS"
13244 > LIBS="-lmpi  $LIBS"
13245   cat >conftest.$ac_ext <<_ACEOF
13246   /* confdefs.h.  */
13247   _ACEOF
# Line 9671 | Line 13256 | char MPI_Init ();
13256   /* We use char because int might match the return type of a gcc2
13257     builtin and then its argument prototype would still apply.  */
13258   char MPI_Init ();
13259 + #ifdef FC_DUMMY_MAIN
13260 + #ifndef FC_DUMMY_MAIN_EQ_F77
13261 + #  ifdef __cplusplus
13262 +     extern "C"
13263 + #  endif
13264 +   int FC_DUMMY_MAIN() { return 1; }
13265 + #endif
13266 + #endif
13267   int
13268   main ()
13269   {
# Line 9688 | Line 13281 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13281    cat conftest.err >&5
13282    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13283    (exit $ac_status); } &&
13284 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13284 >         { ac_try='test -z "$ac_c_werror_flag"
13285 >                         || test ! -s conftest.err'
13286    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13287    (eval $ac_try) 2>&5
13288    ac_status=$?
# Line 9714 | Line 13308 | if test $ac_cv_lib_mpi_MPI_Init = yes; then
13308   echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13309   echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13310   if test $ac_cv_lib_mpi_MPI_Init = yes; then
13311 <  MPI_LIB="-lmpi -llam"
13311 >  MPI_LIB="-lmpi"
13312   fi
13313  
13314   fi
13315 < $as_unset ac_cv_lib_mpich_MPI_Init
13315 > $as_unset ac_cv_lib_mpi_MPI_Init
13316   if test x = x"$MPI_LIB"; then
13317 <        echo "$as_me:$LINENO: checking for MPI_Init in -lmpich" >&5
13318 < echo $ECHO_N "checking for MPI_Init in -lmpich... $ECHO_C" >&6
13319 < if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then
13317 >        echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
13318 > echo $ECHO_N "checking for MPI_Init in -lmpi... $ECHO_C" >&6
13319 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then
13320    echo $ECHO_N "(cached) $ECHO_C" >&6
13321   else
13322    ac_check_lib_save_LIBS=$LIBS
13323 < LIBS="-lmpich "-lpmpich" $LIBS"
13323 > LIBS="-lmpi -llam $LIBS"
13324   cat >conftest.$ac_ext <<_ACEOF
13325   /* confdefs.h.  */
13326   _ACEOF
# Line 9741 | Line 13335 | char MPI_Init ();
13335   /* We use char because int might match the return type of a gcc2
13336     builtin and then its argument prototype would still apply.  */
13337   char MPI_Init ();
13338 + #ifdef FC_DUMMY_MAIN
13339 + #ifndef FC_DUMMY_MAIN_EQ_F77
13340 + #  ifdef __cplusplus
13341 +     extern "C"
13342 + #  endif
13343 +   int FC_DUMMY_MAIN() { return 1; }
13344 + #endif
13345 + #endif
13346   int
13347   main ()
13348   {
# Line 9758 | Line 13360 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13360    cat conftest.err >&5
13361    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13362    (exit $ac_status); } &&
13363 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13363 >         { ac_try='test -z "$ac_c_werror_flag"
13364 >                         || test ! -s conftest.err'
13365    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13366    (eval $ac_try) 2>&5
13367    ac_status=$?
# Line 9770 | Line 13373 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13373    ac_status=$?
13374    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13375    (exit $ac_status); }; }; then
13376 <  ac_cv_lib_mpich_MPI_Init=yes
13376 >  ac_cv_lib_mpi_MPI_Init=yes
13377   else
13378    echo "$as_me: failed program was:" >&5
13379   sed 's/^/| /' conftest.$ac_ext >&5
13380  
13381 < ac_cv_lib_mpich_MPI_Init=no
13381 > ac_cv_lib_mpi_MPI_Init=no
13382   fi
13383   rm -f conftest.err conftest.$ac_objext \
13384        conftest$ac_exeext conftest.$ac_ext
13385   LIBS=$ac_check_lib_save_LIBS
13386   fi
13387 < echo "$as_me:$LINENO: result: $ac_cv_lib_mpich_MPI_Init" >&5
13388 < echo "${ECHO_T}$ac_cv_lib_mpich_MPI_Init" >&6
13389 < if test $ac_cv_lib_mpich_MPI_Init = yes; then
13390 <  MPI_LIB="-lmpich -lpmpich"
13387 > echo "$as_me:$LINENO: result: $ac_cv_lib_mpi_MPI_Init" >&5
13388 > echo "${ECHO_T}$ac_cv_lib_mpi_MPI_Init" >&6
13389 > if test $ac_cv_lib_mpi_MPI_Init = yes; then
13390 >  MPI_LIB="-lmpi -llam"
13391   fi
13392  
13393   fi
9791 –
13394   $as_unset ac_cv_lib_mpi_MPI_Init
13395   if test x = x"$MPI_LIB"; then
13396   echo "$as_me:$LINENO: checking for MPI_Init in -lmpi" >&5
# Line 9812 | Line 13414 | char MPI_Init ();
13414   /* We use char because int might match the return type of a gcc2
13415     builtin and then its argument prototype would still apply.  */
13416   char MPI_Init ();
13417 + #ifdef FC_DUMMY_MAIN
13418 + #ifndef FC_DUMMY_MAIN_EQ_F77
13419 + #  ifdef __cplusplus
13420 +     extern "C"
13421 + #  endif
13422 +   int FC_DUMMY_MAIN() { return 1; }
13423 + #endif
13424 + #endif
13425   int
13426   main ()
13427   {
# Line 9829 | Line 13439 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
13439    cat conftest.err >&5
13440    echo "$as_me:$LINENO: \$? = $ac_status" >&5
13441    (exit $ac_status); } &&
13442 <         { ac_try='test -z "$ac_c_werror_flag"                   || test ! -s conftest.err'
13442 >         { ac_try='test -z "$ac_c_werror_flag"
13443 >                         || test ! -s conftest.err'
13444    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
13445    (eval $ac_try) 2>&5
13446    ac_status=$?
# Line 9888 | Line 13499 | fi
13499  
13500  
13501  
9891 – USE_CGAL=no
9892 – cgal_makefile=auto
9893 –
9894 – # Check whether --with-cgal-makefile or --without-cgal-makefile was given.
9895 – if test "${with_cgal_makefile+set}" = set; then
9896 –  withval="$with_cgal_makefile"
9897 –  cgal_makefile="$withval"
9898 – fi;
9899 –
9900 – if test "x$cgal_makefile" != xno; then
9901 –
9902 –  if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
9903 –    cgal_makefile="$CGAL_MAKEFILE"
9904 –  fi
9905 –
9906 –  echo "$as_me:$LINENO: checking for cgal_makefile: $cgal_makefile" >&5
9907 – echo $ECHO_N "checking for cgal_makefile: $cgal_makefile... $ECHO_C" >&6
9908 –
9909 –  if test -f "$cgal_makefile"; then
9910 –
9911 –    cat >config.tmp.Makefile <<EOF
9912 – include $cgal_makefile
9913 – default:
9914 –        @echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
9915 –        @echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
9916 –        @echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
9917 –        @echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
9918 –        @echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
9919 –        @echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
9920 –        @echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
9921 –        @echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
9922 –        @echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
9923 –        @echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
9924 –        @echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
9925 –        @echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
9926 – EOF
9927 –
9928 –    make -s -f config.tmp.Makefile
9929 –    . config.tmp.cgalvariables
9930 –
9931 –    rm -f config.tmp.Makefile config.tmp.cgalvariables
9932 –
9933 –    if test "x$CGAL_INCLDIR" = "x"; then
9934 –      CGAL_INCLDIR=""
9935 –    fi
9936 –
9937 –    if test "x$CGAL_LIBDIR" = "x"; then
9938 –      CGAL_LIBDIR=""
9939 –    fi
9940 –
9941 –    if test "x$CGAL_RLIBDIR" = "x"; then
9942 –      CGAL_RLIBDIR=""
9943 –    fi
9944 –
9945 –    if test "x$LEDA_INCLDIR" = "x"; then
9946 –      LEDA_INCLDIR=""
9947 –    fi
9948 –
9949 –    if test "x$LEDA_LIBDIR" = "x"; then
9950 –      LEDA_LIBDIR=""
9951 –    fi
9952 –
9953 –    if test "x$LEDA_RLIBDIR" = "x"; then
9954 –      LEDA_RLIBDIR=""
9955 –    fi
9956 –
9957 –    if test "x$GMP_INCLDIR" = "x"; then
9958 –      GMP_INCLDIR=""
9959 –    fi
9960 –
9961 –    if test "x$GMP_LIBDIR" = "x"; then
9962 –      GMP_LIBDIR=""
9963 –    fi
9964 –
9965 –    if test "x$GMP_RLIBDIR" = "x"; then
9966 –      GMP_RLIBDIR=""
9967 –    fi
9968 –
9969 –    echo "$as_me:$LINENO: result: CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&5
9970 – echo "${ECHO_T}CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&6
9971 –    echo "$as_me:$LINENO: result: CGAL_INCLDIR=       $CGAL_INCLDIR" >&5
9972 – echo "${ECHO_T}CGAL_INCLDIR=       $CGAL_INCLDIR" >&6
9973 –    echo "$as_me:$LINENO: result: CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&5
9974 – echo "${ECHO_T}CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&6
9975 –    echo "$as_me:$LINENO: result: CGAL_LIBDIR=        $CGAL_LIBDIR" >&5
9976 – echo "${ECHO_T}CGAL_LIBDIR=        $CGAL_LIBDIR" >&6
9977 –    echo "$as_me:$LINENO: result: CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&5
9978 – echo "${ECHO_T}CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&6
9979 –    echo "$as_me:$LINENO: result: LEDA_INCLDIR=       $LEDA_INCLDIR" >&5
9980 – echo "${ECHO_T}LEDA_INCLDIR=       $LEDA_INCLDIR" >&6
9981 –    echo "$as_me:$LINENO: result: LEDA_LIBDIR=        $LEDA_LIBDIR" >&5
9982 – echo "${ECHO_T}LEDA_LIBDIR=        $LEDA_LIBDIR" >&6
9983 –    echo "$as_me:$LINENO: result: GMP_INCLDIR=        $GMP_INCLDIR" >&5
9984 – echo "${ECHO_T}GMP_INCLDIR=        $GMP_INCLDIR" >&6
9985 –    echo "$as_me:$LINENO: result: GMP_LIBDIR=         $GMP_LIBDIR" >&5
9986 – echo "${ECHO_T}GMP_LIBDIR=         $GMP_LIBDIR" >&6
9987 –
9988 –    ac_ext=cc
9989 – ac_cpp='$CXXCPP $CPPFLAGS'
9990 – ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9991 – ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9992 – ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9993 –
9994 –    save_CXXFLAGS="$CXXFLAGS"
9995 –    CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
9996 –    if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
9997 –  echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
9998 – echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
9999 – if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
10000 –  echo $ECHO_N "(cached) $ECHO_C" >&6
10001 – fi
10002 – echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
10003 – echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
10004 – else
10005 –  # Is the header compilable?
10006 – echo "$as_me:$LINENO: checking CGAL/Cartesian.h usability" >&5
10007 – echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
10008 – cat >conftest.$ac_ext <<_ACEOF
10009 – /* confdefs.h.  */
10010 – _ACEOF
10011 – cat confdefs.h >>conftest.$ac_ext
10012 – cat >>conftest.$ac_ext <<_ACEOF
10013 – /* end confdefs.h.  */
10014 – $ac_includes_default
10015 – #include <CGAL/Cartesian.h>
10016 – _ACEOF
10017 – rm -f conftest.$ac_objext
10018 – if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10019 –  (eval $ac_compile) 2>conftest.er1
10020 –  ac_status=$?
10021 –  grep -v '^ *+' conftest.er1 >conftest.err
10022 –  rm -f conftest.er1
10023 –  cat conftest.err >&5
10024 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10025 –  (exit $ac_status); } &&
10026 –         { ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
10027 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10028 –  (eval $ac_try) 2>&5
10029 –  ac_status=$?
10030 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10031 –  (exit $ac_status); }; } &&
10032 –         { ac_try='test -s conftest.$ac_objext'
10033 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10034 –  (eval $ac_try) 2>&5
10035 –  ac_status=$?
10036 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10037 –  (exit $ac_status); }; }; then
10038 –  ac_header_compiler=yes
10039 – else
10040 –  echo "$as_me: failed program was:" >&5
10041 – sed 's/^/| /' conftest.$ac_ext >&5
10042 –
10043 – ac_header_compiler=no
10044 – fi
10045 – rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10046 – echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10047 – echo "${ECHO_T}$ac_header_compiler" >&6
10048 –
10049 – # Is the header present?
10050 – echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
10051 – echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
10052 – cat >conftest.$ac_ext <<_ACEOF
10053 – /* confdefs.h.  */
10054 – _ACEOF
10055 – cat confdefs.h >>conftest.$ac_ext
10056 – cat >>conftest.$ac_ext <<_ACEOF
10057 – /* end confdefs.h.  */
10058 – #include <CGAL/Cartesian.h>
10059 – _ACEOF
10060 – if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10061 –  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10062 –  ac_status=$?
10063 –  grep -v '^ *+' conftest.er1 >conftest.err
10064 –  rm -f conftest.er1
10065 –  cat conftest.err >&5
10066 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10067 –  (exit $ac_status); } >/dev/null; then
10068 –  if test -s conftest.err; then
10069 –    ac_cpp_err=$ac_cxx_preproc_warn_flag
10070 –    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10071 –  else
10072 –    ac_cpp_err=
10073 –  fi
10074 – else
10075 –  ac_cpp_err=yes
10076 – fi
10077 – if test -z "$ac_cpp_err"; then
10078 –  ac_header_preproc=yes
10079 – else
10080 –  echo "$as_me: failed program was:" >&5
10081 – sed 's/^/| /' conftest.$ac_ext >&5
10082 –
10083 –  ac_header_preproc=no
10084 – fi
10085 – rm -f conftest.err conftest.$ac_ext
10086 – echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10087 – echo "${ECHO_T}$ac_header_preproc" >&6
10088 –
10089 – # So?  What about this header?
10090 – case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10091 –  yes:no: )
10092 –    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
10093 – echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
10094 –    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
10095 – echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
10096 –    ac_header_preproc=yes
10097 –    ;;
10098 –  no:yes:* )
10099 –    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&5
10100 – echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
10101 –    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
10102 – echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
10103 –    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
10104 – echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
10105 –    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
10106 – echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
10107 –    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
10108 – echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
10109 –    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
10110 – echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
10111 –    (
10112 –      cat <<\_ASBOX
10113 – ## ------------------------------ ##
10114 – ## Report this to gezelter@nd.edu ##
10115 – ## ------------------------------ ##
10116 – _ASBOX
10117 –    ) |
10118 –      sed "s/^/$as_me: WARNING:     /" >&2
10119 –    ;;
10120 – esac
10121 – echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
10122 – echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
10123 – if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
10124 –  echo $ECHO_N "(cached) $ECHO_C" >&6
10125 – else
10126 –  ac_cv_header_CGAL_Cartesian_h=$ac_header_preproc
10127 – fi
10128 – echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
10129 – echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
10130 –
10131 – fi
10132 – if test $ac_cv_header_CGAL_Cartesian_h = yes; then
10133 –  cgal=yes
10134 – else
10135 –  cgal=no
10136 – fi
10137 –
10138 –
10139 –    CXXFLAGS="$save_CXXFLAGS"
10140 –
10141 –    if test "x$cgal" = xyes; then
10142 –      echo "$as_me:$LINENO: checking for CGAL version" >&5
10143 – echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
10144 –      LOCATION=${CGAL_INCLDIR}
10145 –      LOCATION=${LOCATION:-/usr/include}
10146 –      if test -f $LOCATION/CGAL/version.h; then
10147 –        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
10148 –      else
10149 –        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
10150 –      fi
10151 –      if echo $CGAL_VERSION | grep -q "^[3456789]"; then
10152 –        echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
10153 – echo "${ECHO_T}($CGAL_VERSION) yes" >&6
10154 –      else
10155 –        echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
10156 – echo "${ECHO_T}($CGAL_VERSION) no" >&6
10157 –        cgal=no
10158 –      fi
10159 –    fi
10160 –
10161 –    if test "x$cgal" = xyes; then
10162 –      CGAL_LIBS="-lCGAL"
10163 –      echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
10164 – echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
10165 –      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
10166 –        CGAL_USES_LEDA=yes
10167 –        echo "$as_me:$LINENO: result: yes" >&5
10168 – echo "${ECHO_T}yes" >&6
10169 –        CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
10170 –      else
10171 –        echo "$as_me:$LINENO: result: no" >&5
10172 – echo "${ECHO_T}no" >&6
10173 –        CGAL_USES_LEDA=no
10174 –      fi
10175 –
10176 –      echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
10177 – echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
10178 –      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
10179 –        CGAL_USES_GMP=yes
10180 –        echo "$as_me:$LINENO: result: yes" >&5
10181 – echo "${ECHO_T}yes" >&6
10182 –        CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
10183 –      else
10184 –        echo "$as_me:$LINENO: result: no" >&5
10185 – echo "${ECHO_T}no" >&6
10186 –        CGAL_USES_GMP=no
10187 –      fi
10188 –
10189 –      CGAL_LIBS="$CGAL_LIBS -lm"
10190 –
10191 –      CGAL_CXXFLAGS="-ftemplate-depth-50"
10192 –
10193 –      echo "$as_me:$LINENO: result: CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&5
10194 – echo "${ECHO_T}CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&6
10195 –      echo "$as_me:$LINENO: result: CGAL_USES_GMP =     $CGAL_USES_GMP" >&5
10196 – echo "${ECHO_T}CGAL_USES_GMP =     $CGAL_USES_GMP" >&6
10197 –      echo "$as_me:$LINENO: result: CGAL_INCLDIR  =     $CGAL_INCLDIR" >&5
10198 – echo "${ECHO_T}CGAL_INCLDIR  =     $CGAL_INCLDIR" >&6
10199 –      echo "$as_me:$LINENO: result: CGAL_LIBDIR   =     $CGAL_LIBDIR" >&5
10200 – echo "${ECHO_T}CGAL_LIBDIR   =     $CGAL_LIBDIR" >&6
10201 –      echo "$as_me:$LINENO: result: CGAL_DEFINES  =     $CGAL_DEFINES" >&5
10202 – echo "${ECHO_T}CGAL_DEFINES  =     $CGAL_DEFINES" >&6
10203 –      echo "$as_me:$LINENO: result: CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&5
10204 – echo "${ECHO_T}CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&6
10205 –      echo "$as_me:$LINENO: result: CGAL_LIBS     =     $CGAL_LIBS" >&5
10206 – echo "${ECHO_T}CGAL_LIBS     =     $CGAL_LIBS" >&6
10207 –    fi
10208 –
10209 –    if test "x$cgal" = xyes; then
10210 –      save_LIBS="$LIBS"
10211 –      LIBS="$LIBS -L$CGAL_LIBDIR"
10212 –      if test "x$CGAL_USES_LEDA" = xyes; then
10213 –        LIBS="-lL $LIBS -L$LEDA_LIBDIR"
10214 –      fi
10215 –      # if test "x$CGAL_USES_GMP" = xyes; then
10216 –      #   LIBS="-lgmp $LIBS $GMP_LIBDIR"
10217 –      # fi
10218 –      echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
10219 – echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
10220 – save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
10221 – CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
10222 – save_LIBS_CHECK_CXX_LIB="$LIBS"
10223 – LIBS="-lCGAL  $LIBS"
10224 – cat >conftest.$ac_ext <<_ACEOF
10225 – /* confdefs.h.  */
10226 – _ACEOF
10227 – cat confdefs.h >>conftest.$ac_ext
10228 – cat >>conftest.$ac_ext <<_ACEOF
10229 – /* end confdefs.h.  */
10230 – #include <CGAL/Cartesian.h>
10231 – int
10232 – main ()
10233 – {
10234 – ::CGAL::Cartesian<int>::Point_2 P
10235 –  ;
10236 –  return 0;
10237 – }
10238 – _ACEOF
10239 – rm -f conftest.$ac_objext conftest$ac_exeext
10240 – if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10241 –  (eval $ac_link) 2>conftest.er1
10242 –  ac_status=$?
10243 –  grep -v '^ *+' conftest.er1 >conftest.err
10244 –  rm -f conftest.er1
10245 –  cat conftest.err >&5
10246 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10247 –  (exit $ac_status); } &&
10248 –         { ac_try='test -z "$ac_cxx_werror_flag"                         || test ! -s conftest.err'
10249 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10250 –  (eval $ac_try) 2>&5
10251 –  ac_status=$?
10252 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10253 –  (exit $ac_status); }; } &&
10254 –         { ac_try='test -s conftest$ac_exeext'
10255 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10256 –  (eval $ac_try) 2>&5
10257 –  ac_status=$?
10258 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10259 –  (exit $ac_status); }; }; then
10260 –  echo "$as_me:$LINENO: result: yes" >&5
10261 – echo "${ECHO_T}yes" >&6
10262 – cgal=yes
10263 – else
10264 –  echo "$as_me: failed program was:" >&5
10265 – sed 's/^/| /' conftest.$ac_ext >&5
10266 –
10267 – echo "$as_me:$LINENO: result: no" >&5
10268 – echo "${ECHO_T}no" >&6
10269 – cgal=no
10270 – fi
10271 – rm -f conftest.err conftest.$ac_objext \
10272 –      conftest$ac_exeext conftest.$ac_ext
10273 – CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
10274 – LIBS="$save_LIBS_CHECK_CXX_LIB"
10275 –      LIBS="$save_LIBS"
10276 –    fi
10277 –
10278 –  fi
10279 –  ac_ext=c
10280 – ac_cpp='$CPP $CPPFLAGS'
10281 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10282 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10283 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
10284 –
10285 –
10286 – fi
10287 –
10288 – if test "x$cgal" = xyes; then
10289 –  USE_CGAL=yes
10290 –
10291 – cat >>confdefs.h <<\_ACEOF
10292 – #define HAVE_CGAL 1
10293 – _ACEOF
10294 –
10295 –
10296 – cat >>confdefs.h <<_ACEOF
10297 – #define CGAL_VERSION $CGAL_VERSION
10298 – _ACEOF
10299 –
10300 –  if ! echo $CGAL_VERSION | grep -q "^3.0"; then
10301 –    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
10302 – echo "$as_me: WARNING: *****************************************************" >&2;}
10303 –    { echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
10304 – echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
10305 –    { echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
10306 – echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
10307 –    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
10308 – echo "$as_me: WARNING: *****************************************************" >&2;}
10309 –  fi
10310 – else
10311 –   if test "x$cgal_makefile" != xno; then
10312 –    echo "$as_me:$LINENO: result: No CGAL support. These are not the droids you want." >&5
10313 – echo "${ECHO_T}No CGAL support. These are not the droids you want." >&6
10314 –  fi
10315 –  CGAL_INCLDIR=
10316 –  CGAL_LIBDIR=
10317 –  CGAL_RLIBDIR=
10318 –  CGAL_DEFINES=
10319 –  CGAL_CXXFLAGS=
10320 –  CGAL_LIBS=
10321 – fi
10322 –
10323 –
10324 – CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
10325 –
10326 – CGAL_LIB_DIR=${CGAL_LIBDIR}
10327 –
10328 – CGAL_RLIB_DIR=${CGAL_RLIBDIR}
10329 –
10330 –
10331 –
10332 –
10333 –
10334 –
10335 –
13502   # Check whether --enable-doxygen or --disable-doxygen was given.
13503   if test "${enable_doxygen+set}" = set; then
13504    enableval="$enable_doxygen"
# Line 10467 | Line 13633 | fi
13633   else
13634          enable_dot=yes
13635   fi
10470 –
10471 –
10472 –
10473 –
10474 –
10475 –
10476 –
10477 – OBJEXT=".$OBJEXT"
10478 –
10479 – OOPSE=oopse
10480 –
10481 – if test "x${prefix}" = "xNONE"
10482 – then
10483 –  OOPSE_HOME=${ac_default_prefix}/oopse
10484 – else
10485 –  OOPSE_HOME=${prefix}/oopse
10486 – fi
10487 – # Check whether --enable-oopse-home or --disable-oopse-home was given.
10488 – if test "${enable_oopse_home+set}" = set; then
10489 –  enableval="$enable_oopse_home"
10490 –  OOPSE_HOME="${enableval}"
10491 – fi;
10492 –
10493 – case "x$INSTALL" in
10494 –   x/*) ;;
10495 –   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
10496 – esac
10497 –
10498 – MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
10499 –
10500 – CFLAGS=${CFLAGS-""}
10501 – CXXFLAGS=${CXXFLAGS-""}
10502 – CPPFLAGS=${CPPFLAGS-""}
10503 – FFLAGS=${FFLAGS-""}
10504 – F90FLAGS=${F90FLAGS-""}
10505 – LDFLAGS=${LDFLAGS-""}
10506 – DEBUG=${DEBUG-"-g"}
13636  
10508 – case $debug in
10509 –  1)
10510 –     FFLAGS="$DEBUG $FFLAGS"
10511 –     F90FLAGS="$DEBUG $F90FLAGS"
10512 –     ;;
10513 –  *)
10514 –     ;;
10515 – esac
13637  
13638  
13639  
# Line 10531 | Line 13652 | esac
13652  
13653  
13654  
13655 <          ac_config_headers="$ac_config_headers src/config.h"
10535 <
10536 <                                        ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/applications/nanoRodBuilder/Makefile scripts/filepp"
13655 >                              ac_config_files="$ac_config_files make/Makefile src/utils/Makefile scripts/filepp"
13656  
13657  
13658   cat >confcache <<\_ACEOF
# Line 10898 | Line 14017 | cat >&5 <<_CSEOF
14017   } >&5
14018   cat >&5 <<_CSEOF
14019  
14020 < This file was extended by OOPSE $as_me 2.0, which was
14020 > This file was extended by OOPSE $as_me 3.0, which was
14021   generated by GNU Autoconf 2.59.  Invocation command line was
14022  
14023    CONFIG_FILES    = $CONFIG_FILES
# Line 10961 | Line 14080 | ac_cs_version="\\
14080  
14081   cat >>$CONFIG_STATUS <<_ACEOF
14082   ac_cs_version="\\
14083 < OOPSE config.status 2.0
14083 > OOPSE config.status 3.0
14084   configured by $0, generated by GNU Autoconf 2.59,
14085    with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
14086  
# Line 11066 | Line 14185 | do
14185    # Handling of arguments.
14186    "make/Makefile" ) CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
14187    "src/utils/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
11069 –  "src/applications/nanoRodBuilder/Makefile" ) CONFIG_FILES="$CONFIG_FILES src/applications/nanoRodBuilder/Makefile" ;;
14188    "scripts/filepp" ) CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
14189    "src/getopt.h" ) CONFIG_LINKS="$CONFIG_LINKS src/getopt.h:src/utils/gnugetopt.h" ;;
14190    "src/config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS src/config.h" ;;
# Line 11155 | Line 14273 | s,@LIBS@,$LIBS,;t t
14273   s,@ECHO_N@,$ECHO_N,;t t
14274   s,@ECHO_T@,$ECHO_T,;t t
14275   s,@LIBS@,$LIBS,;t t
11158 – s,@PROGNAME@,$PROGNAME,;t t
11159 – s,@debug@,$debug,;t t
14276   s,@build@,$build,;t t
14277   s,@build_cpu@,$build_cpu,;t t
14278   s,@build_vendor@,$build_vendor,;t t
# Line 11165 | Line 14281 | s,@host_os@,$host_os,;t t
14281   s,@host_cpu@,$host_cpu,;t t
14282   s,@host_vendor@,$host_vendor,;t t
14283   s,@host_os@,$host_os,;t t
14284 < s,@CC@,$CC,;t t
14285 < s,@CFLAGS@,$CFLAGS,;t t
14284 > s,@PROGNAME@,$PROGNAME,;t t
14285 > s,@debug@,$debug,;t t
14286 > s,@USE_SINGLE_PRECISION@,$USE_SINGLE_PRECISION,;t t
14287 > s,@CXX@,$CXX,;t t
14288 > s,@CXXFLAGS@,$CXXFLAGS,;t t
14289   s,@LDFLAGS@,$LDFLAGS,;t t
14290   s,@CPPFLAGS@,$CPPFLAGS,;t t
14291 < s,@ac_ct_CC@,$ac_ct_CC,;t t
14291 > s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14292   s,@EXEEXT@,$EXEEXT,;t t
14293   s,@OBJEXT@,$OBJEXT,;t t
14294 < s,@CXX@,$CXX,;t t
14295 < s,@CXXFLAGS@,$CXXFLAGS,;t t
14296 < s,@ac_ct_CXX@,$ac_ct_CXX,;t t
14297 < s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
14298 < s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
14299 < s,@F90@,$F90,;t t
11181 < s,@F90FLAGS@,$F90FLAGS,;t t
11182 < s,@ac_ct_F90@,$ac_ct_F90,;t t
11183 < s,@PREPFLAG@,$PREPFLAG,;t t
11184 < s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
11185 < s,@F90LIBS@,$F90LIBS,;t t
11186 < s,@F90_FUNC@,$F90_FUNC,;t t
11187 < s,@F90_FUNC_@,$F90_FUNC_,;t t
11188 < s,@MOD@,$MOD,;t t
11189 < s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
11190 < s,@MODDIRFLAG@,$MODDIRFLAG,;t t
11191 < s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
11192 < s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14294 > s,@CC@,$CC,;t t
14295 > s,@CFLAGS@,$CFLAGS,;t t
14296 > s,@ac_ct_CC@,$ac_ct_CC,;t t
14297 > s,@FC@,$FC,;t t
14298 > s,@FCFLAGS@,$FCFLAGS,;t t
14299 > s,@ac_ct_FC@,$ac_ct_FC,;t t
14300   s,@CPP@,$CPP,;t t
14301   s,@EGREP@,$EGREP,;t t
11195 – s,@CXXCPP@,$CXXCPP,;t t
11196 – s,@LIBOBJS@,$LIBOBJS,;t t
11197 – s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
11198 – s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
11199 – s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14302   s,@LN_S@,$LN_S,;t t
14303   s,@SET_MAKE@,$SET_MAKE,;t t
14304   s,@RANLIB@,$RANLIB,;t t
14305   s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
11204 – s,@YACC@,$YACC,;t t
11205 – s,@LEX@,$LEX,;t t
11206 – s,@LEXLIB@,$LEXLIB,;t t
11207 – s,@LEX_OUTPUT_ROOT@,$LEX_OUTPUT_ROOT,;t t
14306   s,@PERLINTERP@,$PERLINTERP,;t t
14307   s,@PERL_SHEBANG@,$PERL_SHEBANG,;t t
14308 + s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
14309 + s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
14310 + s,@INSTALL_DATA@,$INSTALL_DATA,;t t
14311   s,@AR@,$AR,;t t
14312   s,@PS@,$PS,;t t
14313 + s,@FCFLAGS_F90@,$FCFLAGS_F90,;t t
14314 + s,@FCFLAGS_SRCEXT@,$FCFLAGS_SRCEXT,;t t
14315 + s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
14316 + s,@FCLIBS@,$FCLIBS,;t t
14317 + s,@FC_FUNC@,$FC_FUNC,;t t
14318 + s,@FC_FUNC_@,$FC_FUNC_,;t t
14319 + s,@MOD@,$MOD,;t t
14320 + s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
14321 + s,@MODDIRFLAG@,$MODDIRFLAG,;t t
14322 + s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
14323 + s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
14324 + s,@ZLIB_INC_DIR@,$ZLIB_INC_DIR,;t t
14325 + s,@ZLIB_LIB_DIR@,$ZLIB_LIB_DIR,;t t
14326 + s,@ZLIB@,$ZLIB,;t t
14327 + s,@FFTW_INC_DIR@,$FFTW_INC_DIR,;t t
14328 + s,@FFTW_LIB_DIR@,$FFTW_LIB_DIR,;t t
14329 + s,@FFTW_LIBS@,$FFTW_LIBS,;t t
14330 + s,@LIBOBJS@,$LIBOBJS,;t t
14331 + s,@POW_LIB@,$POW_LIB,;t t
14332 + s,@CXXCPP@,$CXXCPP,;t t
14333 + s,@__func__@,$__func__,;t t
14334   s,@MPI_LIB_DIR@,$MPI_LIB_DIR,;t t
14335   s,@MPI_INC_DIR@,$MPI_INC_DIR,;t t
14336   s,@MPI_F90_INC@,$MPI_F90_INC,;t t
14337   s,@MPI_LIB@,$MPI_LIB,;t t
14338   s,@MPI_F90_LIB@,$MPI_F90_LIB,;t t
14339   s,@USE_MPI@,$USE_MPI,;t t
11218 – s,@USE_CGAL@,$USE_CGAL,;t t
11219 – s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
11220 – s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
11221 – s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
11222 – s,@CGAL_DEFINES@,$CGAL_DEFINES,;t t
11223 – s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
11224 – s,@CGAL_LIBS@,$CGAL_LIBS,;t t
14340   s,@DOXYGEN@,$DOXYGEN,;t t
14341   s,@DOT@,$DOT,;t t
14342   s,@DOC@,$DOC,;t t
# Line 11233 | Line 14348 | s,@SUBDIRS@,$SUBDIRS,;t t
14348   s,@OOPSE@,$OOPSE,;t t
14349   s,@OOPSE_HOME@,$OOPSE_HOME,;t t
14350   s,@SUBDIRS@,$SUBDIRS,;t t
11236 – s,@FFLAGS@,$FFLAGS,;t t
14351   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
14352   CEOF
14353  
# Line 11401 | Line 14515 | esac
14515    *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
14516    esac
14517  
14518 +  if test x"$ac_file" != x-; then
14519 +    { echo "$as_me:$LINENO: creating $ac_file" >&5
14520 + echo "$as_me: creating $ac_file" >&6;}
14521 +    rm -f "$ac_file"
14522 +  fi
14523    # Let's still pretend it is `configure' which instantiates (i.e., don't
14524    # use $as_me), people would be surprised to read:
14525    #    /* config.h.  Generated by config.status.  */
# Line 11439 | Line 14558 | echo "$as_me: error: cannot find input file: $f" >&2;}
14558           fi;;
14559        esac
14560      done` || { (exit 1); exit 1; }
11442 –
11443 –  if test x"$ac_file" != x-; then
11444 –    { echo "$as_me:$LINENO: creating $ac_file" >&5
11445 – echo "$as_me: creating $ac_file" >&6;}
11446 –    rm -f "$ac_file"
11447 –  fi
14561   _ACEOF
14562   cat >>$CONFIG_STATUS <<_ACEOF
14563    sed "$ac_vpsub
# Line 11476 | Line 14589 | s,@INSTALL@,$ac_INSTALL,;t t
14589    case $ac_file in
14590      make/Makefile ) chmod 0755 scripts/* ;;
14591      src/utils/Makefile ) chmod 0755 scripts/* ;;
11479 –    src/applications/nanoRodBuilder/Makefile ) chmod 0755 scripts/* ;;
14592      scripts/filepp ) chmod 0755 scripts/* ;;
14593    esac
14594   done

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines