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 819 by tim, Fri Dec 16 21:52:50 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 CPP EGREP 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 CXXCPP LIBOBJS __func__ 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
756 > ac_env_CXX_set=${CXX+set}
757 > ac_env_CXX_value=$CXX
758 > ac_cv_env_CXX_set=${CXX+set}
759 > ac_cv_env_CXX_value=$CXX
760 > ac_env_CXXFLAGS_set=${CXXFLAGS+set}
761 > ac_env_CXXFLAGS_value=$CXXFLAGS
762 > ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
763 > ac_cv_env_CXXFLAGS_value=$CXXFLAGS
764   ac_env_LDFLAGS_set=${LDFLAGS+set}
765   ac_env_LDFLAGS_value=$LDFLAGS
766   ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
# Line 769 | Line 769 | ac_cv_env_CPPFLAGS_value=$CPPFLAGS
769   ac_env_CPPFLAGS_value=$CPPFLAGS
770   ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
771   ac_cv_env_CPPFLAGS_value=$CPPFLAGS
772 < ac_env_CXX_set=${CXX+set}
773 < ac_env_CXX_value=$CXX
774 < ac_cv_env_CXX_set=${CXX+set}
775 < ac_cv_env_CXX_value=$CXX
776 < ac_env_CXXFLAGS_set=${CXXFLAGS+set}
777 < ac_env_CXXFLAGS_value=$CXXFLAGS
778 < ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
779 < ac_cv_env_CXXFLAGS_value=$CXXFLAGS
772 > ac_env_CC_set=${CC+set}
773 > ac_env_CC_value=$CC
774 > ac_cv_env_CC_set=${CC+set}
775 > ac_cv_env_CC_value=$CC
776 > ac_env_CFLAGS_set=${CFLAGS+set}
777 > ac_env_CFLAGS_value=$CFLAGS
778 > ac_cv_env_CFLAGS_set=${CFLAGS+set}
779 > ac_cv_env_CFLAGS_value=$CFLAGS
780 > ac_env_FC_set=${FC+set}
781 > ac_env_FC_value=$FC
782 > ac_cv_env_FC_set=${FC+set}
783 > ac_cv_env_FC_value=$FC
784 > ac_env_FCFLAGS_set=${FCFLAGS+set}
785 > ac_env_FCFLAGS_value=$FCFLAGS
786 > ac_cv_env_FCFLAGS_set=${FCFLAGS+set}
787 > ac_cv_env_FCFLAGS_value=$FCFLAGS
788   ac_env_CPP_set=${CPP+set}
789   ac_env_CPP_value=$CPP
790   ac_cv_env_CPP_set=${CPP+set}
791   ac_cv_env_CPP_value=$CPP
784 ac_env_F90_set=${F90+set}
785 ac_env_F90_value=$F90
786 ac_cv_env_F90_set=${F90+set}
787 ac_cv_env_F90_value=$F90
788 ac_env_F90FLAGS_set=${F90FLAGS+set}
789 ac_env_F90FLAGS_value=$F90FLAGS
790 ac_cv_env_F90FLAGS_set=${F90FLAGS+set}
791 ac_cv_env_F90FLAGS_value=$F90FLAGS
792   ac_env_CXXCPP_set=${CXXCPP+set}
793   ac_env_CXXCPP_value=$CXXCPP
794   ac_cv_env_CXXCPP_set=${CXXCPP+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
899 >  CC          C compiler command
900 >  CFLAGS      C compiler flags
901 >  FC          Fortran compiler command
902 >  FCFLAGS     Fortran compiler flags
903    CPP         C preprocessor
900  F90         Fortran 90 compiler command
901  F90FLAGS    Fortran 90 compiler flags
904    CXXCPP      C++ preprocessor
905  
906   Use these variables to override the choices made by `configure' or to help
# Line 1000 | Line 1002 | if $ac_init_version; then
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 1374 | Line 1376 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1376   ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1377   ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1378   ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1377
1378
1379 # 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).
1428
1429
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
1453
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
1464
1465
1466
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
1496
1497
1498
1499 ## ----------------------- ##
1500 ## 1. Language selection.  ##
1501 ## ----------------------- ##
1502
1503 # ----------------------------- #
1504 # 1b. The Fortran 90 language.  #
1505 # ----------------------------- #
1506
1507 # AC_LANG(Fortran 90)
1508 # -------------------
1509
1510
1511
1512 # _AC_LANG_ABBREV(Fortran 90)
1513 # ---------------------------
1514
1515
1516
1517 # ----------------------------- #
1518 # 1c. The Fortran 95 language.  #
1519 # ----------------------------- #
1520
1521 # AC_LANG(Fortran 95)
1522 # -------------------
1523
1524
1525
1526 # _AC_LANG_ABBREV(Fortran 95)
1527 # ---------------------------
1528
1529
1530
1531 ## ---------------------- ##
1532 ## 2.Producing programs.  ##
1533 ## ---------------------- ##
1534
1535 # ------------------------ #
1536 # 2b. Fortran 90 sources.  #
1537 # ------------------------ #
1538
1539 # AC_LANG_SOURCE(Fortran 90)(BODY)
1540 # --------------------------------
1541
1542
1543
1544 # AC_LANG_PROGRAM(Fortran 90)([PROLOGUE], [BODY])
1545 # -----------------------------------------------
1546
1547
1548 # AC_LANG_CALL(Fortran 90)(PROLOGUE, FUNCTION)
1549 # --------------------------------------------
1550
1551
1552
1553 # ------------------------ #
1554 # 2c. Fortran 95 sources.  #
1555 # ------------------------ #
1379  
1557 # AC_LANG_SOURCE(Fortran 95)(BODY)
1558 # --------------------------------
1380  
1381 +          ac_config_headers="$ac_config_headers src/config.h"
1382  
1561 # AC_LANG_PROGRAM(Fortran 95)([PROLOGUE], [BODY])
1562 # -----------------------------------------------
1383  
1384  
1565 # AC_LANG_CALL(Fortran 95)(PROLOGUE, FUNCTION)
1566 # --------------------------------------------
1385  
1386  
1387  
1570 ## -------------------------------------------- ##
1571 ## 3. Looking for Compilers and Preprocessors.  ##
1572 ## -------------------------------------------- ##
1388  
1574 # ----------------------------- #
1575 # 3b. The Fortran 90 compiler.  #
1576 # ----------------------------- #
1389  
1390  
1579 # AC_LANG_PREPROC(Fortran 90)
1580 # ---------------------------
1581 # Find the Fortran 90 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1391  
1392  
1393  
1585 # AC_LANG_COMPILER(Fortran 90)
1586 # ----------------------------
1587 # Find the Fortran 90 compiler.  Must be AC_DEFUN'd to be
1588 # AC_REQUIRE'able.
1394  
1395  
1396  
1592 # AC_PROG_F90([COMPILERS...])
1593 # ---------------------------
1594 # COMPILERS is a space separated list of Fortran 90 compilers to search
1595 # for.
1596 #
1597 # Compilers are ordered by
1598 #  1. F90, F95
1599 #  2. Good/tested native compilers, bad/untested native compilers
1600 #
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
1397  
1398  
1609 # ----------------------------- #
1610 # 3c. The Fortran 95 compiler.  #
1611 # ----------------------------- #
1399  
1400  
1614 # AC_LANG_PREPROC(Fortran 95)
1615 # ---------------------------
1616 # Find the Fortran 95 preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
1401  
1402  
1403  
1620 # AC_LANG_COMPILER(Fortran 95)
1621 # ----------------------------
1622 # Find the Fortran 95 compiler.  Must be AC_DEFUN'd to be
1623 # AC_REQUIRE'able.
1404  
1405  
1406  
1627 # AC_PROG_F95([COMPILERS...])
1628 # ---------------------------
1629 # COMPILERS is a space separated list of Fortran 95 compilers to search
1630 # for.
1631 #
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
1407  
1408  
1641 ## ------------------------------- ##
1642 ## 4. Compilers' characteristics.  ##
1643 ## ------------------------------- ##
1409  
1645
1646 # ---------------------------------------- #
1647 # 4b. Fortan 90 compiler characteristics.  #
1648 # ---------------------------------------- #
1649
1650
1651 # _AC_PROG_F90_V_OUTPUT([FLAG = $ac_cv_prog_f90_v])
1652 # -------------------------------------------------
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 # --------------
1664 #
1665 # 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 # ----------------------
1674 #
1675 # 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
1698
1699
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
1410  
1717 # The replacement is empty.
1411  
1412  
1413  
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
1414  
1415  
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
1416  
1417  
1738 # ---------------------------------------- #
1739 # 4c. Fortan 95 compiler characteristics.  #
1740 # ---------------------------------------- #
1418  
1419  
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
1420  
1421  
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
1422  
1423  
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
1424  
1425  
1792 # _AC_F95_NAME_MANGLING
1793 # ---------------------
1794 # Test for the name mangling scheme used by the Fortran 95 compiler.
1426   #
1796 # Sets ac_cv_f95_mangling. The value contains three fields, separated
1797 # by commas:
1427   #
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
1428   #
1807 # _AC_F95_NAME_MANGLING
1429  
1809 # The replacement is empty.
1430  
1431  
1432  
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
1433  
1434  
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
1828
1435   # AC_F90_MODULE_NAMES
1436   # -------------------
1437   #
# Line 1885 | Line 1491 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1491  
1492  
1493  
1888 #
1889 #
1890 #
1494  
1495  
1496  
# Line 1923 | Line 1526 | ac_configure="$SHELL $ac_aux_dir/configure" # This sho
1526  
1527  
1528  
1926
1927
1928
1929
1930
1931
1932
1933 # set program name
1934 PROGNAME="oopse"
1935
1936
1937 # there are two ways to do debugging.  One with the --enable-debug flag
1938 # and one using the DEBUG environment variable
1939
1940 debug=0
1941 # Check whether --enable-debug or --disable-debug was given.
1942 if test "${enable_debug+set}" = set; then
1943  enableval="$enable_debug"
1944  debug=1
1945 fi;
1946 if test "${DEBUG}"; then
1947
1948 cat >>confdefs.h <<\_ACEOF
1949 #define debug 1
1950 _ACEOF
1951
1952  msg="$msg, debug mode"
1953 fi
1954
1955
1529   # who am i
1530   # Make sure we can run config.sub.
1531   $ac_config_sub sun4 >/dev/null 2>&1 ||
# Line 2011 | 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 pathcc 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 2036 | 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 2045 | 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 pathcc 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 2078 | 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 2087 | 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  
2106 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
2107 See \`config.log' for more details." >&5
2108 echo "$as_me: error: no acceptable C compiler found in \$PATH
2109 See \`config.log' for more details." >&2;}
2110   { (exit 1); exit 1; }; }
2111
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 2149 | 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 2193 | 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 2206 | 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 2222 | 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 2330 | 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 2362 | 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"
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
# Line 2383 | 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 2421 | 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"
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
# Line 2434 | 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
2464 < echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
2465 < if test "${ac_cv_prog_cc_stdc+set}" = set; then
2466 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2467 < else
2468 <  ac_cv_prog_cc_stdc=no
2469 < ac_save_CC=$CC
2470 < cat >conftest.$ac_ext <<_ACEOF
2471 < /* confdefs.h.  */
2472 < _ACEOF
2473 < cat confdefs.h >>conftest.$ac_ext
2474 < cat >>conftest.$ac_ext <<_ACEOF
2475 < /* end confdefs.h.  */
2476 < #include <stdarg.h>
2477 < #include <stdio.h>
2478 < #include <sys/types.h>
2479 < #include <sys/stat.h>
2480 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
2481 < struct buf { int x; };
2482 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
2483 < static char *e (p, i)
2484 <     char **p;
2485 <     int i;
2486 < {
2487 <  return p[i];
2488 < }
2489 < static char *f (char * (*g) (char **, int), char **p, ...)
2490 < {
2491 <  char *s;
2492 <  va_list v;
2493 <  va_start (v,p);
2494 <  s = g (p, va_arg (v,int));
2495 <  va_end (v);
2496 <  return s;
2497 < }
2498 <
2499 < /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
2500 <   function prototypes and stuff, but not '\xHH' hex character constants.
2501 <   These don't provoke an error unfortunately, instead are silently treated
2502 <   as 'x'.  The following induces an error, until -std1 is added to get
2503 <   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
2504 <   array size at least.  It's necessary to write '\x00'==0 to get something
2505 <   that's true only with -std1.  */
2506 < int osf4_cc_array ['\x00' == 0 ? 1 : -1];
2507 <
2508 < int test (int i, double x);
2509 < struct s1 {int (*f) (int a);};
2510 < struct s2 {int (*f) (double a);};
2511 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
2512 < int argc;
2513 < char **argv;
2514 < int
2515 < main ()
2516 < {
2517 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
2518 <  ;
2519 <  return 0;
2520 < }
2521 < _ACEOF
2522 < # Don't try gcc -ansi; that turns off useful extensions and
2523 < # breaks some systems' header files.
2524 < # AIX                   -qlanglvl=ansi
2525 < # Ultrix and OSF/1      -std1
2526 < # HP-UX 10.20 and later -Ae
2527 < # HP-UX older versions  -Aa -D_HPUX_SOURCE
2528 < # SVR4                  -Xc -D__EXTENSIONS__
2529 < for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
2530 < do
2531 <  CC="$ac_save_CC $ac_arg"
2532 <  rm -f conftest.$ac_objext
2533 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2534 <  (eval $ac_compile) 2>conftest.er1
2535 <  ac_status=$?
2536 <  grep -v '^ *+' conftest.er1 >conftest.err
2537 <  rm -f conftest.er1
2538 <  cat conftest.err >&5
2539 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2540 <  (exit $ac_status); } &&
2541 <         { ac_try='test -z "$ac_c_werror_flag"
2542 <                         || test ! -s conftest.err'
2543 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2544 <  (eval $ac_try) 2>&5
2545 <  ac_status=$?
2546 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2547 <  (exit $ac_status); }; } &&
2548 <         { ac_try='test -s conftest.$ac_objext'
2549 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2550 <  (eval $ac_try) 2>&5
2551 <  ac_status=$?
2552 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2553 <  (exit $ac_status); }; }; then
2554 <  ac_cv_prog_cc_stdc=$ac_arg
2555 < break
2556 < else
2557 <  echo "$as_me: failed program was:" >&5
2558 < sed 's/^/| /' conftest.$ac_ext >&5
2559 <
2560 < fi
2561 < rm -f conftest.err conftest.$ac_objext
2562 < done
2563 < rm -f conftest.$ac_ext conftest.$ac_objext
2564 < CC=$ac_save_CC
2565 <
2566 < fi
2567 <
2568 < case "x$ac_cv_prog_cc_stdc" in
2569 <  x|xno)
2570 <    echo "$as_me:$LINENO: result: none needed" >&5
2571 < echo "${ECHO_T}none needed" >&6 ;;
2572 <  *)
2573 <    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
2574 < echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
2575 <    CC="$CC $ac_cv_prog_cc_stdc" ;;
2576 < esac
2577 <
2578 < # Some people use a C++ compiler to compile C.  Since we use `exit',
2579 < # in C++ we need to declare it.  In case someone uses the same compiler
2580 < # for both compiling C and C++ we need to have the C++ compiler decide
2581 < # the declaration of exit, since it's the most demanding environment.
2582 < cat >conftest.$ac_ext <<_ACEOF
2583 < #ifndef __cplusplus
2584 <  choke me
2585 < #endif
2586 < _ACEOF
2587 < rm -f conftest.$ac_objext
2588 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2589 <  (eval $ac_compile) 2>conftest.er1
2590 <  ac_status=$?
2591 <  grep -v '^ *+' conftest.er1 >conftest.err
2592 <  rm -f conftest.er1
2593 <  cat conftest.err >&5
2594 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2595 <  (exit $ac_status); } &&
2596 <         { ac_try='test -z "$ac_c_werror_flag"
2597 <                         || test ! -s conftest.err'
2598 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2599 <  (eval $ac_try) 2>&5
2600 <  ac_status=$?
2601 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2602 <  (exit $ac_status); }; } &&
2603 <         { ac_try='test -s conftest.$ac_objext'
2604 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2605 <  (eval $ac_try) 2>&5
2606 <  ac_status=$?
2607 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2608 <  (exit $ac_status); }; }; then
2609 <  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 2639 | 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"
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
# Line 2684 | 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"
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
# Line 2712 | Line 2198 | fi
2198    echo '#endif'             >>confdefs.h
2199   fi
2200  
2715 else
2716  echo "$as_me: failed program was:" >&5
2717 sed 's/^/| /' conftest.$ac_ext >&5
2718
2719 fi
2720 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'
2732 < 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 pathCC 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 2750 | 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 2759 | 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 pathCC 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 2792 | 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 2801 | 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
2292 >  test -n "$ac_ct_CC" && break
2293   done
2815 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
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 2838 | 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 2870 | 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"
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
# Line 2891 | 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 2929 | 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"
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
# Line 2942 | 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
2979 <  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 ()
2472 < {
2473 < exit (42);
2474 <  ;
2475 <  return 0;
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 >  return p[i];
2480   }
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
# Line 3001 | Line 2585 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2585    cat conftest.err >&5
2586    echo "$as_me:$LINENO: \$? = $ac_status" >&5
2587    (exit $ac_status); } &&
2588 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 3014 | Line 2598 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&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=$?
2639 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2640 +  (exit $ac_status); }; } &&
2641 +         { ac_try='test -s conftest.$ac_objext'
2642 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2643 +  (eval $ac_try) 2>&5
2644 +  ac_status=$?
2645 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2646 +  (exit $ac_status); }; }; then
2647    :
2648   else
2649    echo "$as_me: failed program was:" >&5
# Line 3046 | 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"
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
# Line 3074 | 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 + 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 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_FC+set}" = set; then
2731 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2732 + else
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
2738 + do
2739 +  IFS=$as_save_IFS
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_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
2747 + done
2748 + done
2749 +
2750 + fi
2751 + fi
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 "$FC" && break
2762 +  done
2763 + fi
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_FC+set}" = set; then
2773 +  echo $ECHO_N "(cached) $ECHO_C" >&6
2774 + else
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
2780 + do
2781 +  IFS=$as_save_IFS
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_FC="$ac_prog"
2786 +    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2787 +    break 2
2788 +  fi
2789 + done
2790 + done
2791 +
2792 + fi
2793 + fi
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_FC" && break
2804 + done
2805 +
2806 +  FC=$ac_ct_FC
2807 + fi
2808 +
2809 +
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=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 +      program main
2842 + #ifndef __GNUC__
2843 +       choke me
2844 + #endif
2845  
2846 +      end
2847 + _ACEOF
2848 + rm -f conftest.$ac_objext
2849 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2850 +  (eval $ac_compile) 2>conftest.er1
2851 +  ac_status=$?
2852 +  grep -v '^ *+' conftest.er1 >conftest.err
2853 +  rm -f conftest.er1
2854 +  cat conftest.err >&5
2855 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2856 +  (exit $ac_status); } &&
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=$?
2862 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2863 +  (exit $ac_status); }; } &&
2864 +         { ac_try='test -s conftest.$ac_objext'
2865 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2866 +  (eval $ac_try) 2>&5
2867 +  ac_status=$?
2868 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2869 +  (exit $ac_status); }; }; then
2870 +  ac_compiler_gnu=yes
2871 + else
2872 +  echo "$as_me: failed program was:" >&5
2873 + sed 's/^/| /' conftest.$ac_ext >&5
2874 +
2875 + ac_compiler_gnu=no
2876 + fi
2877 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2878 + ac_cv_fc_compiler_gnu=$ac_compiler_gnu
2879 +
2880 + fi
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 + 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 +      end
2897 + _ACEOF
2898 + rm -f conftest.$ac_objext
2899 + if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
2900 +  (eval $ac_compile) 2>conftest.er1
2901 +  ac_status=$?
2902 +  grep -v '^ *+' conftest.er1 >conftest.err
2903 +  rm -f conftest.er1
2904 +  cat conftest.err >&5
2905 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2906 +  (exit $ac_status); } &&
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=$?
2912 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2913 +  (exit $ac_status); }; } &&
2914 +         { ac_try='test -s conftest.$ac_objext'
2915 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
2916 +  (eval $ac_try) 2>&5
2917 +  ac_status=$?
2918 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2919 +  (exit $ac_status); }; }; then
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 + ac_cv_prog_fc_g=no
2926 + fi
2927 + rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
2928 +
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.
# Line 3315 | Line 3185 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
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  
3318
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
# Line 3331 | Line 3200 | echo "${ECHO_T}$ac_cv_prog_egrep" >&6
3200   EGREP=$ac_cv_prog_egrep
3201  
3202  
3203 <
3204 < OOPSE_TEMPLATE_FLAGS=""
3205 < if test $ac_cv_cxx_compiler_gnu = no; then
3206 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -ptused -no_prelink" >&5
3207 < echo $ECHO_N "checking checking whether ${CXX} accepts -ptused -no_prelink... $ECHO_C" >&6
3339 <  echo 'void f(){}' > conftest.cc
3340 <  if test -z "`${CXX} -ptused -no_prelink -c conftest.cc 2>&1`"; then
3341 <    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 <    OOPSE_TEMPLATE_FLAGS="-ptused -no_prelink"
3210 <  else
3211 <    echo "$as_me:$LINENO: result: no" >&5
3212 < echo "${ECHO_T}no" >&6
3213 <  fi
3214 <  rm -f conftest*
3215 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -instances=static" >&5
3216 < echo $ECHO_N "checking checking whether ${CXX} accepts -instances=static... $ECHO_C" >&6
3217 <  echo 'void f(){}' > conftest.cc
3218 <  if test -z "`${CXX} -instances=static -c conftest.cc 2>&1`"; then
3219 <    echo "$as_me:$LINENO: result: yes" >&5
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 > 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 <    OOPSE_TEMPLATE_FLAGS="-instances=static"
3237 <  else
3238 <    echo "$as_me:$LINENO: result: no" >&5
3236 >  SET_MAKE=
3237 > else
3238 >  echo "$as_me:$LINENO: result: no" >&5
3239 > echo "${ECHO_T}no" >&6
3240 >  SET_MAKE="MAKE=${MAKE-make}"
3241 > fi
3242 >
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 >
3268 > fi
3269 > 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:$LINENO: result: no" >&5
3276   echo "${ECHO_T}no" >&6
3277 + fi
3278 +
3279 + fi
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 -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 <  rm -f conftest*
3304 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -pto" >&5
3305 < echo $ECHO_N "checking checking whether ${CXX} accepts -pto... $ECHO_C" >&6
3306 <  echo 'void f(){}' > conftest.cc
3307 <  if test -z "`${CXX} -pto -c conftest.cc 2>&1`"; then
3308 <    echo "$as_me:$LINENO: result: yes" >&5
3309 < echo "${ECHO_T}yes" >&6
3310 <    OOPSE_TEMPLATE_FLAGS="-pto"
3311 <  else
3312 <    echo "$as_me:$LINENO: result: no" >&5
3303 > done
3304 > done
3305 >
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 +  RANLIB=$ac_ct_RANLIB
3319 + else
3320 +  RANLIB="$ac_cv_prog_RANLIB"
3321 + fi
3322 +
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 <  rm -f conftest*
3348 <  echo "$as_me:$LINENO: checking checking whether ${CXX} accepts -LANG:std" >&5
3374 < echo $ECHO_N "checking checking whether ${CXX} accepts -LANG:std... $ECHO_C" >&6
3375 <  echo 'void f(){}' > conftest.cc
3376 <  if test -z "`${CXX} -LANG:std -c conftest.cc 2>&1`"; then
3377 <    echo "$as_me:$LINENO: result: yes" >&5
3378 < echo "${ECHO_T}yes" >&6
3347 > done
3348 > done
3349  
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 <    EXTRA_CC_FLAG=${EXTRA_CC_FLAG}" -LANG:std"
3357 <  else
3358 <    echo "$as_me:$LINENO: result: no" >&5
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_path_perlinterp="$PERLINTERP"
3365 +   _sHpB='#!'
3366 +
3367 +
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 < ac_ext=f90
3522 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3523 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3524 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3525 < if test -n "$ac_tool_prefix"; then
3526 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3527 <  do
3398 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3399 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
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_F90+set}" = set; then
3530 > if test "${ac_cv_prog_AR+set}" = set; then
3531    echo $ECHO_N "(cached) $ECHO_C" >&6
3532   else
3533 <  if test -n "$F90"; then
3534 <  ac_cv_prog_F90="$F90" # Let the user override the test.
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
# Line 3412 | Line 3540 | do
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_F90="$ac_tool_prefix$ac_prog"
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 < F90=$ac_cv_prog_F90
3554 < if test -n "$F90"; then
3555 <  echo "$as_me:$LINENO: result: $F90" >&5
3556 < echo "${ECHO_T}$F90" >&6
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 <    test -n "$F90" && break
3563 <  done
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 < if test -z "$F90"; then
3617 <  ac_ct_F90=$F90
3618 <  for ac_prog in pathf95 ifort ifc f90 xlf90 pgf90 epcf90 f95 xlf95 lf95 fort g95
3619 < do
3620 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3441 < set dummy $ac_prog; ac_word=$2
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_prog_ac_ct_F90+set}" = set; then
3623 > if test "${ac_cv_path_PS+set}" = set; then
3624    echo $ECHO_N "(cached) $ECHO_C" >&6
3625   else
3626 <  if test -n "$ac_ct_F90"; then
3627 <  ac_cv_prog_ac_ct_F90="$ac_ct_F90" # Let the user override the test.
3628 < else
3629 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
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_prog_ac_ct_F90="$ac_prog"
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 < fi
3649 < ac_ct_F90=$ac_cv_prog_ac_ct_F90
3650 < if test -n "$ac_ct_F90"; then
3651 <  echo "$as_me:$LINENO: result: $ac_ct_F90" >&5
3652 < echo "${ECHO_T}$ac_ct_F90" >&6
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 <  test -n "$ac_ct_F90" && break
3659 < done
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 <  F90=$ac_ct_F90
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 we don't use `.F90' as extension, the preprocessor is not run on the
3695 < # input file.
3696 < ac_save_ext=$ac_ext
3697 < ac_ext=F90
3698 < echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 90 compiler" >&5
3699 < echo $ECHO_N "checking whether we are using the GNU Fortran 90 compiler... $ECHO_C" >&6
3488 < if test "${ac_cv_f90_compiler_gnu+set}" = set; then
3489 <  echo $ECHO_N "(cached) $ECHO_C" >&6
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 <  cat >conftest.$ac_ext <<_ACEOF
3701 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
3702  
3703 < program main
3703 > cat >>confdefs.h <<\_ACEOF
3704 > #define PSTYPE_IS_POSIX 1
3705 > _ACEOF
3706  
3707 < #ifndef __GNUC__
3708 <       choke me
3709 < #endif
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 < end program main
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
# Line 3508 | Line 3742 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3742    cat conftest.err >&5
3743    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3744    (exit $ac_status); } &&
3745 <         { ac_try='test -z "$ac_f90_werror_flag"
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
# Line 3521 | Line 3755 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3755    ac_status=$?
3756    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3757    (exit $ac_status); }; }; then
3758 <  ac_compiler_gnu=yes
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  
3529 ac_compiler_gnu=no
3763   fi
3764   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3765 < ac_cv_f90_compiler_gnu=$ac_compiler_gnu
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_f90_compiler_gnu" >&5
3771 < echo "${ECHO_T}$ac_cv_f90_compiler_gnu" >&6
3772 < ac_ext=$ac_save_ext
3773 < G95=`test $ac_compiler_gnu = yes && echo yes`
3774 < ac_ext=c
3775 < ac_cpp='$CPP $CPPFLAGS'
3776 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3777 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3778 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
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  
# Line 3553 | Line 3797 | if test "$ac_test_PREPFLAG" != "set"; then
3797    PREPFLAG=""
3798    case "${host_cpu}-${host_os}" in
3799  
3800 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3800 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3801                      PREPFLAG="-fpp1 "
3802                  fi;;
3803 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
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 "$F90" = f90 -o "$F90" = xlf90; then
3807 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3808                  PREPFLAG="-qsuffix=cpp=F90 "
3809          fi;;
3810    esac
# Line 3575 | Line 3819 | echo $ECHO_N "checking to make sure F90 preprocessor f
3819   echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6
3820  
3821  
3822 <  ac_ext=f90
3823 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3824 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3825 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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_F90FLAGS=$F90FLAGS
3829 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
3830  
3831    if test "$PREPFLAG"; then
3832 <  F90FLAGS="${F90FLAGS} ${PREPFLAG}-DTEST"
3832 >  FCFLAGS_SRCEXT="${PREPFLAG}"
3833   fi
3834  
3835      cat >conftest.$ac_ext <<_ACEOF
3836  
3837  
3838 < program main
3595 <
3838 > program conftest
3839    integer :: i
3840    i = 1
3841 + end program conftest
3842  
3599
3600 end program main
3601
3843   _ACEOF
3844   rm -f conftest.$ac_objext
3845   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3609 | Line 3850 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3850    cat conftest.err >&5
3851    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3852    (exit $ac_status); } &&
3853 <         { ac_try='test -z "$ac_f90_werror_flag"
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
# Line 3631 | Line 3872 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3872   fi
3873   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3874  
3875 <  F90FLAGS=$ac_save_F90FLAGS
3875 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
3876    ac_ext=$ac_save_ext
3877 <  ac_ext=c
3878 < ac_cpp='$CPP $CPPFLAGS'
3879 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3880 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3640 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
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
# Line 3664 | Line 3905 | if test "$ac_test_PREPDEFFLAG" != "set"; then
3905    PREPDEFFLAG=""
3906    case "${host_cpu}-${host_os}" in
3907  
3908 <  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
3908 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
3909                      PREPDEFFLAG=" "
3910                  fi;;
3911 <  *aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
3911 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
3912                      PREPDEFFLAG="-WF,"
3913                  fi;;
3914    *darwin*)
3915 <        if test "$F90" = f90 -o "$F90" = xlf90; then
3915 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
3916                  PREPDEFFLAG="-WF,"
3917          fi;;
3918    esac
# Line 3686 | Line 3927 | echo $ECHO_N "checking to make sure F90 preprocessor d
3927   echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6
3928  
3929  
3930 <  ac_ext=f90
3931 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3932 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3933 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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_F90FLAGS=$F90FLAGS
3937 >  ac_save_FCFLAGS=$FCFLAGS
3938  
3939    if test "$PREPDEFFLAG"; then
3940 <  F90FLAGS="${F90FLAGS} ${PREPFLAG} ${PREPDEFFLAG}-DTEST"
3940 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
3941   fi
3942  
3943      cat >conftest.$ac_ext <<_ACEOF
3944  
3945  
3946 < program main
3706 <
3946 > program conftest
3947    integer :: i
3948   #ifdef TEST
3949    i = 1
3950   #else
3951    choke me
3952   #endif
3953 + end program conftest
3954  
3714
3715 end program main
3716
3955   _ACEOF
3956   rm -f conftest.$ac_objext
3957   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3724 | Line 3962 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3962    cat conftest.err >&5
3963    echo "$as_me:$LINENO: \$? = $ac_status" >&5
3964    (exit $ac_status); } &&
3965 <         { ac_try='test -z "$ac_f90_werror_flag"
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
# Line 3746 | Line 3984 | rm -f conftest.err conftest.$ac_objext conftest.$ac_ex
3984   fi
3985   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3986  
3987 <  F90FLAGS=$ac_save_F90FLAGS
3987 >  FCFLAGS=$ac_save_FCFLAGS
3988    ac_ext=$ac_save_ext
3989 <  ac_ext=c
3990 < ac_cpp='$CPP $CPPFLAGS'
3991 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3992 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3755 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
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  
3758
3995    if test "$prepdefflagworks" = 1; then
3996      echo "$as_me:$LINENO: result: yes" >&5
3997   echo "${ECHO_T}yes" >&6
# Line 3769 | Line 4005 | fi
4005    fi
4006   fi
4007  
4008 < ac_ext=f90
4009 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4010 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4011 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4012 <
4013 <
4014 <
3779 < ac_ext=f90
3780 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3781 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3782 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3783 < echo "$as_me:$LINENO: checking how to get verbose linking output from $F90" >&5
3784 < echo $ECHO_N "checking how to get verbose linking output from $F90... $ECHO_C" >&6
3785 < if test "${ac_cv_prog_f90_v+set}" = set; then
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 < cat >conftest.$ac_ext <<_ACEOF
3790 <
3791 < program main
3792 <
3793 <
3794 < end program main
3795 <
4020 >      end
4021   _ACEOF
4022   rm -f conftest.$ac_objext
4023   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 3803 | Line 4028 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4028    cat conftest.err >&5
4029    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4030    (exit $ac_status); } &&
4031 <         { ac_try='test -z "$ac_f90_werror_flag"
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
# Line 3816 | Line 4041 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4041    ac_status=$?
4042    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4043    (exit $ac_status); }; }; then
4044 <  ac_cv_prog_f90_v=
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 <  ac_ext=f90
4048 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3824 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3825 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4047 >  cat >conftest.$ac_ext <<_ACEOF
4048 >      program main
4049  
4050 < cat >conftest.$ac_ext <<_ACEOF
3828 <
3829 < program main
3830 <
3831 <
3832 < end program main
3833 <
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 90 compiler in order to get
4055 < # "verbose" output that we can then parse for the Fortran 90 linker
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_F90FLAGS=$F90FLAGS
4058 < F90FLAGS="$F90FLAGS $ac_verb"
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 < (eval echo $as_me:3843: \"$ac_link\") >&5
3844 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3845 < echo "$ac_f90_v_output" >&5
3846 < F90FLAGS=$ac_save_F90FLAGS
4064 > rm -f conftest*
4065  
4066 < rm -f conftest.*
4067 < ac_ext=f90
4068 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4069 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4070 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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 < # If we are using xlf then replace all the commas with spaces.
4074 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4075 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4076 < fi
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 < # If we are using Cray Fortran then delete quotes.
4079 < # Use "\"" instead of '"' for font-lock-mode.
4080 < # FIXME: a more general fix for quoted arguments with spaces?
4081 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
4082 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
4083 < fi
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_f90_v_output; do
4092 >  for ac_arg in $ac_fc_v_output; do
4093       case $ac_arg in
4094          [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
4095 <          ac_cv_prog_f90_v=$ac_verb
4095 >          ac_cv_prog_fc_v=$ac_verb
4096            break 2 ;;
4097       esac
4098    done
4099   done
4100 < if test -z "$ac_cv_prog_f90_v"; then
4101 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $F90" >&5
4102 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $F90" >&2;}
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
# Line 3885 | Line 4111 | fi
4111   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4112  
4113   fi
4114 < echo "$as_me:$LINENO: result: $ac_cv_prog_f90_v" >&5
4115 < echo "${ECHO_T}$ac_cv_prog_f90_v" >&6
4116 < echo "$as_me:$LINENO: checking for Fortran 90 libraries" >&5
4117 < echo $ECHO_N "checking for Fortran 90 libraries... $ECHO_C" >&6
4118 < if test "${ac_cv_flibs+set}" = set; then
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$F90LIBS" != "x"; then
4122 <  ac_cv_f90libs="$F90LIBS" # Let the user override the test.
4121 >  if test "x$FCLIBS" != "x"; then
4122 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
4123   else
4124  
3899 ac_ext=f90
3900 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
3901 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3902 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
3903
4125   cat >conftest.$ac_ext <<_ACEOF
4126 +      program main
4127  
4128 < program main
3907 <
3908 <
3909 < end program main
3910 <
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 90 compiler in order to get
4133 < # "verbose" output that we can then parse for the Fortran 90 linker
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_F90FLAGS=$F90FLAGS
4136 < F90FLAGS="$F90FLAGS $ac_cv_prog_f90_v"
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 < (eval echo $as_me:3920: \"$ac_link\") >&5
3921 < ac_f90_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
3922 < echo "$ac_f90_v_output" >&5
3923 < F90FLAGS=$ac_save_F90FLAGS
4142 > rm -f conftest*
4143  
4144 < rm -f conftest.*
4145 < ac_ext=f90
4146 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4147 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4148 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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 < # If we are using xlf then replace all the commas with spaces.
4152 < if echo $ac_f90_v_output | grep xlfentry >/dev/null 2>&1; then
4153 <  ac_f90_v_output=`echo $ac_f90_v_output | sed 's/,/ /g'`
4154 < fi
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 < # If we are using Cray Fortran then delete quotes.
4157 < # Use "\"" instead of '"' for font-lock-mode.
4158 < # FIXME: a more general fix for quoted arguments with spaces?
4159 < if echo $ac_f90_v_output | grep cft90 >/dev/null 2>&1; then
3940 <  ac_f90_v_output=`echo $ac_f90_v_output | sed "s/\"//g"`
3941 < fi
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 < ac_cv_f90libs=
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_f90_v_output
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 3962 | 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 3980 | 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"
4005
4232                  shift; shift
4233                  set X $ac_arg "$@"
4234                  ;;
# Line 4011 | 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 4022 | 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 4039 | 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 4054 | 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 &&
4060
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  
4077 ac_ext=f90
4078 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4079 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4080 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
4323 < cat >conftest.$ac_ext <<_ACEOF
4324 < subroutine foobar()
4325 < return
4326 < end
4327 < subroutine foo_bar()
4328 < return
4329 < end
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 > # 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 + #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 + #endif
4344 + int
4345 + main ()
4346 + {
4347 +
4348 +  ;
4349 +  return 0;
4350 + }
4351 + _ACEOF
4352 + rm -f conftest.$ac_objext conftest$ac_exeext
4353 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4354 +  (eval $ac_link) 2>conftest.er1
4355 +  ac_status=$?
4356 +  grep -v '^ *+' conftest.er1 >conftest.err
4357 +  rm -f conftest.er1
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"
4362 +                         || test ! -s conftest.err'
4363 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4364 +  (eval $ac_try) 2>&5
4365 +  ac_status=$?
4366 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4367 +  (exit $ac_status); }; } &&
4368 +         { ac_try='test -s conftest$ac_exeext'
4369 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4370 +  (eval $ac_try) 2>&5
4371 +  ac_status=$?
4372 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4373 +  (exit $ac_status); }; }; then
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
4383 +
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 + #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 + #endif
4401 + int
4402 + main ()
4403 + {
4404 +
4405 +  ;
4406 +  return 0;
4407 + }
4408 + _ACEOF
4409 + rm -f conftest.$ac_objext conftest$ac_exeext
4410 + if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4411 +  (eval $ac_link) 2>conftest.er1
4412 +  ac_status=$?
4413 +  grep -v '^ *+' conftest.er1 >conftest.err
4414 +  rm -f conftest.er1
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"
4419 +                         || test ! -s conftest.err'
4420 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4421 +  (eval $ac_try) 2>&5
4422 +  ac_status=$?
4423 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4424 +  (exit $ac_status); }; } &&
4425 +         { ac_try='test -s conftest$ac_exeext'
4426 +  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4427 +  (eval $ac_try) 2>&5
4428 +  ac_status=$?
4429 +  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4430 +  (exit $ac_status); }; }; then
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
4435 +
4436 + fi
4437 + rm -f conftest.err conftest.$ac_objext \
4438 +      conftest$ac_exeext conftest.$ac_ext
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 + 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 + cat >>confdefs.h <<_ACEOF
4457 + #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
4458 + _ACEOF
4459 +
4460 +  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
4461 +
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
# Line 4106 | Line 4505 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4505    cat conftest.err >&5
4506    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4507    (exit $ac_status); } &&
4508 <         { ac_try='test -z "$ac_f90_werror_flag"
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
# Line 4119 | Line 4518 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4518    ac_status=$?
4519    echo "$as_me:$LINENO: \$? = $ac_status" >&5
4520    (exit $ac_status); }; }; then
4521 <  mv conftest.$ac_objext cf90_test.$ac_objext
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
4129
4130  ac_save_LIBS=$LIBS
4131  LIBS="cf90_test.$ac_objext $F90LIBS $LIBS"
4132
4531    ac_success=no
4532    for ac_foobar in foobar FOOBAR; do
4533      for ac_underscore in "" "_"; do
# Line 4148 | Line 4546 | char $ac_func ();
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   {
# Line 4188 | Line 4594 | 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 <           ;;
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 <
4208 <        cat >conftest.$ac_ext <<_ACEOF
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
# Line 4219 | Line 4633 | char $ac_func ();
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   {
# Line 4258 | Line 4680 | rm -f conftest.err conftest.$ac_objext \
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_f90_mangling="$ac_case case"
4689 >        ac_cv_fc_mangling="$ac_case case"
4690          if test -z "$ac_underscore"; then
4691 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no underscore"
4691 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
4692          else
4693 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, underscore"
4268 <
4693 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
4694          fi
4695          if test -z "$ac_extra"; then
4696 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, no extra underscore"
4696 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
4697          else
4698 <           ac_cv_f90_mangling="$ac_cv_f90_mangling, extra underscore"
4698 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
4699          fi
4700        else
4701 <        ac_cv_f90_mangling="unknown"
4701 >        ac_cv_fc_mangling="unknown"
4702        fi
4703    else
4704 <     ac_cv_f90_mangling="unknown"
4280 <
4704 >     ac_cv_fc_mangling="unknown"
4705    fi
4706  
4707    LIBS=$ac_save_LIBS
4708 <  ac_ext=f90
4285 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4286 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4287 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4288 <  rm -f cf90_test* conftest*
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
4295 ac_ext=f90
4296 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
4297 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4298 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
4720  
4721   fi
4722 < echo "$as_me:$LINENO: result: $ac_cv_f90_mangling" >&5
4723 < echo "${ECHO_T}$ac_cv_f90_mangling" >&6
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 < case $ac_cv_f90_mangling in
4735 >
4736 > case $ac_cv_fc_mangling in
4737    "lower case, no underscore, no extra underscore")
4738            cat >>confdefs.h <<\_ACEOF
4739 < #define F90_FUNC(name,NAME) name
4739 > #define FC_FUNC(name,NAME) name
4740   _ACEOF
4741  
4742            cat >>confdefs.h <<\_ACEOF
4743 < #define F90_FUNC_(name,NAME) name
4743 > #define FC_FUNC_(name,NAME) name
4744   _ACEOF
4745   ;;
4746    "lower case, no underscore, extra underscore")
4747            cat >>confdefs.h <<\_ACEOF
4748 < #define F90_FUNC(name,NAME) name
4748 > #define FC_FUNC(name,NAME) name
4749   _ACEOF
4750  
4751            cat >>confdefs.h <<\_ACEOF
4752 < #define F90_FUNC_(name,NAME) name ## _
4752 > #define FC_FUNC_(name,NAME) name ## _
4753   _ACEOF
4754   ;;
4755    "lower case, underscore, no extra underscore")
4756            cat >>confdefs.h <<\_ACEOF
4757 < #define F90_FUNC(name,NAME) name ## _
4757 > #define FC_FUNC(name,NAME) name ## _
4758   _ACEOF
4759  
4760            cat >>confdefs.h <<\_ACEOF
4761 < #define F90_FUNC_(name,NAME) name ## _
4761 > #define FC_FUNC_(name,NAME) name ## _
4762   _ACEOF
4763   ;;
4764    "lower case, underscore, extra underscore")
4765            cat >>confdefs.h <<\_ACEOF
4766 < #define F90_FUNC(name,NAME) name ## _
4766 > #define FC_FUNC(name,NAME) name ## _
4767   _ACEOF
4768  
4769            cat >>confdefs.h <<\_ACEOF
4770 < #define F90_FUNC_(name,NAME) name ## __
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 F90_FUNC(name,NAME) NAME
4775 > #define FC_FUNC(name,NAME) NAME
4776   _ACEOF
4777  
4778            cat >>confdefs.h <<\_ACEOF
4779 < #define F90_FUNC_(name,NAME) NAME
4779 > #define FC_FUNC_(name,NAME) NAME
4780   _ACEOF
4781   ;;
4782    "upper case, no underscore, extra underscore")
4783            cat >>confdefs.h <<\_ACEOF
4784 < #define F90_FUNC(name,NAME) NAME
4784 > #define FC_FUNC(name,NAME) NAME
4785   _ACEOF
4786  
4787            cat >>confdefs.h <<\_ACEOF
4788 < #define F90_FUNC_(name,NAME) NAME ## _
4788 > #define FC_FUNC_(name,NAME) NAME ## _
4789   _ACEOF
4790   ;;
4791    "upper case, underscore, no extra underscore")
4792            cat >>confdefs.h <<\_ACEOF
4793 < #define F90_FUNC(name,NAME) NAME ## _
4793 > #define FC_FUNC(name,NAME) NAME ## _
4794   _ACEOF
4795  
4796            cat >>confdefs.h <<\_ACEOF
4797 < #define F90_FUNC_(name,NAME) NAME ## _
4797 > #define FC_FUNC_(name,NAME) NAME ## _
4798   _ACEOF
4799   ;;
4800    "upper case, underscore, extra underscore")
4801            cat >>confdefs.h <<\_ACEOF
4802 < #define F90_FUNC(name,NAME) NAME ## _
4802 > #define FC_FUNC(name,NAME) NAME ## _
4803   _ACEOF
4804  
4805            cat >>confdefs.h <<\_ACEOF
4806 < #define F90_FUNC_(name,NAME) NAME ## __
4806 > #define FC_FUNC_(name,NAME) NAME ## __
4807   _ACEOF
4808   ;;
4809    *)
4810 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran 90 name-mangling scheme" >&5
4811 < echo "$as_me: WARNING: unknown Fortran 90 name-mangling scheme" >&2;}
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.f90 <<EOF
5129 > cat >conftest.$ac_ext <<EOF
5130          module conftest
5131          integer n
5132          parameter (n=1)
# Line 4400 | Line 5135 | modcase="lower"
5135   # SGI and absoft compilers generates module name in upper case!
5136   testname="conftest"
5137   modcase="lower"
5138 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5139 <    MOD=`ls conftest* | grep -v conftest.f | grep -v conftest.o`
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.f | grep -v CONFTEST.o`
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"
# Line 4445 | Line 5180 | rm -f work*
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.f90 <<EOF
5183 > cat >conftest.$ac_ext <<EOF
5184          module conftest
5185          integer n
5186          parameter (n=1)
# Line 4453 | Line 5188 | testname="conftest"
5188   EOF
5189   # SGI and absoft compilers generates module name in upper case!
5190   testname="conftest"
5191 < if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5192 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.f | grep -v CONFTEST.o`
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"
# Line 4463 | Line 5198 | if $F90 -c conftest.f90 > conftest.out 2>&1 ; then
5198     if test ! -d conf ; then mkdir conf ; madedir=1; fi
5199     cp $testname.$MOD conf
5200     rm -f conftest* CONFTEST*
5201 <   cat >conftest1.f90 <<EOF
5201 >   cat >conftest1.$ac_ext <<EOF
5202          program main
5203          use conftest
5204          print *, n
# Line 4471 | Line 5206 | EOF
5206   EOF
5207     F90_WORK_FILES_ARG=""
5208     F90MODINCSPEC=""
5209 <   if $F90 -c -Iconf conftest1.f90 > conftest.out 2>&1 ; then
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 $F90 -c -Mconf conftest1.f90 >> conftest.out 2>&1 ; then
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 $F90 -c -pconf conftest1.f90 >> conftest.out 2>&1 ; then
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
# Line 4490 | Line 5225 | echo "${ECHO_T}-p" >&6
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 $F90 -c -cl,conf/mpimod.pcl conftest1.f >>conftest.out 2>&1 ; then
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
# Line 4520 | Line 5255 | else
5255   if test "${ac_cv_f90_module_names+set}" = set; then
5256    echo $ECHO_N "(cached) $ECHO_C" >&6
5257   else
5258 <  ac_ext=f90
5259 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5260 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5261 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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
# Line 4541 | Line 5276 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5276    cat conftest.err >&5
5277    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5278    (exit $ac_status); } &&
5279 <         { ac_try='test -z "$ac_f90_werror_flag"
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
# Line 4657 | Line 5392 | rm -rf conftest
5392   cd ..
5393   # cleanup
5394   rm -rf conftest
5395 < ac_ext=f90
5396 < ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
5397 < ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5398 < ac_compiler_gnu=$ac_cv_f90_compiler_gnu
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
# Line 4749 | Line 5484 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5484   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5485  
5486  
5487 < ac_ext=cc
5488 < ac_cpp='$CXXCPP $CPPFLAGS'
5489 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5490 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5491 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
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 < ac_ext=cc
5495 < ac_cpp='$CXXCPP $CPPFLAGS'
5496 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5497 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4763 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
4764 < echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
4765 < echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
4766 < if test -z "$CXXCPP"; then
4767 <  if test "${ac_cv_prog_CXXCPP+set}" = set; then
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 <      # Double quotes because CXXCPP needs to be expanded
5501 <    for CXXCPP in "$CXX -E" "/lib/cpp"
5502 <    do
4773 <      ac_preproc_ok=false
4774 < for ac_cxx_preproc_warn_flag in '' yes
4775 < do
4776 <  # Use a header file that comes with gcc, so configuring glibc
4777 <  # with a fresh cross-compiler works.
4778 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4779 <  # <limits.h> exists even on freestanding compilers.
4780 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4781 <  # not just through cpp. "Syntax error" is here to catch this case.
4782 <  cat >conftest.$ac_ext <<_ACEOF
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 < #ifdef __STDC__
5509 < # include <limits.h>
5510 < #else
5511 < # include <assert.h>
5512 < #endif
5513 <                     Syntax error
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 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5533 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
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); } >/dev/null; then
5541 <  if test -s conftest.err; then
5542 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5543 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5544 <  else
4807 <    ac_cpp_err=
4808 <  fi
4809 < else
4810 <  ac_cpp_err=yes
4811 < fi
4812 < if test -z "$ac_cpp_err"; then
4813 <  :
4814 < else
4815 <  echo "$as_me: failed program was:" >&5
4816 < sed 's/^/| /' conftest.$ac_ext >&5
4817 <
4818 <  # Broken: fails on valid input.
4819 < continue
4820 < fi
4821 < rm -f conftest.err conftest.$ac_ext
4822 <
4823 <  # OK, works on sane cases.  Now check whether non-existent headers
4824 <  # can be detected and how.
4825 <  cat >conftest.$ac_ext <<_ACEOF
4826 < /* confdefs.h.  */
4827 < _ACEOF
4828 < cat confdefs.h >>conftest.$ac_ext
4829 < cat >>conftest.$ac_ext <<_ACEOF
4830 < /* end confdefs.h.  */
4831 < #include <ac_nonexistent.h>
4832 < _ACEOF
4833 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4834 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
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=$?
4836  grep -v '^ *+' conftest.er1 >conftest.err
4837  rm -f conftest.er1
4838  cat conftest.err >&5
5546    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5547 <  (exit $ac_status); } >/dev/null; then
5548 <  if test -s conftest.err; then
5549 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
5550 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
5551 <  else
5552 <    ac_cpp_err=
5553 <  fi
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
4848  ac_cpp_err=yes
4849 fi
4850 if test -z "$ac_cpp_err"; then
4851  # Broken: success on invalid input.
4852 continue
4853 else
5556    echo "$as_me: failed program was:" >&5
5557   sed 's/^/| /' conftest.$ac_ext >&5
5558  
5559 <  # Passes both tests.
4858 < ac_preproc_ok=:
4859 < break
5559 > ac_cv_lib_m_asin=no
5560   fi
5561 < rm -f conftest.err conftest.$ac_ext
5562 <
5563 < done
4864 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4865 < rm -f conftest.err conftest.$ac_ext
4866 < if $ac_preproc_ok; then
4867 <  break
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 <    done
4871 <    ac_cv_prog_CXXCPP=$CXXCPP
5572 >  LIBS="-lm $LIBS"
5573  
4873 fi
4874  CXXCPP=$ac_cv_prog_CXXCPP
5574   else
5575 <  ac_cv_prog_CXXCPP=$CXXCPP
4877 < fi
4878 < echo "$as_me:$LINENO: result: $CXXCPP" >&5
4879 < echo "${ECHO_T}$CXXCPP" >&6
4880 < ac_preproc_ok=false
4881 < for ac_cxx_preproc_warn_flag in '' yes
4882 < do
4883 <  # Use a header file that comes with gcc, so configuring glibc
4884 <  # with a fresh cross-compiler works.
4885 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4886 <  # <limits.h> exists even on freestanding compilers.
4887 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4888 <  # not just through cpp. "Syntax error" is here to catch this case.
4889 <  cat >conftest.$ac_ext <<_ACEOF
4890 < /* confdefs.h.  */
4891 < _ACEOF
4892 < cat confdefs.h >>conftest.$ac_ext
4893 < cat >>conftest.$ac_ext <<_ACEOF
4894 < /* end confdefs.h.  */
4895 < #ifdef __STDC__
4896 < # include <limits.h>
4897 < #else
4898 < # include <assert.h>
4899 < #endif
4900 <                     Syntax error
4901 < _ACEOF
4902 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4903 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
4904 <  ac_status=$?
4905 <  grep -v '^ *+' conftest.er1 >conftest.err
4906 <  rm -f conftest.er1
4907 <  cat conftest.err >&5
4908 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4909 <  (exit $ac_status); } >/dev/null; then
4910 <  if test -s conftest.err; then
4911 <    ac_cpp_err=$ac_cxx_preproc_warn_flag
4912 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
4913 <  else
4914 <    ac_cpp_err=
4915 <  fi
4916 < else
4917 <  ac_cpp_err=yes
5575 >  exit
5576   fi
4919 if test -z "$ac_cpp_err"; then
4920  :
4921 else
4922  echo "$as_me: failed program was:" >&5
4923 sed 's/^/| /' conftest.$ac_ext >&5
5577  
4925  # Broken: fails on valid input.
4926 continue
4927 fi
4928 rm -f conftest.err conftest.$ac_ext
5578  
4930  # OK, works on sane cases.  Now check whether non-existent headers
4931  # can be detected and how.
4932  cat >conftest.$ac_ext <<_ACEOF
4933 /* confdefs.h.  */
4934 _ACEOF
4935 cat confdefs.h >>conftest.$ac_ext
4936 cat >>conftest.$ac_ext <<_ACEOF
4937 /* end confdefs.h.  */
4938 #include <ac_nonexistent.h>
4939 _ACEOF
4940 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
4941  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
4942  ac_status=$?
4943  grep -v '^ *+' conftest.er1 >conftest.err
4944  rm -f conftest.er1
4945  cat conftest.err >&5
4946  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4947  (exit $ac_status); } >/dev/null; then
4948  if test -s conftest.err; then
4949    ac_cpp_err=$ac_cxx_preproc_warn_flag
4950    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
4951  else
4952    ac_cpp_err=
4953  fi
4954 else
4955  ac_cpp_err=yes
4956 fi
4957 if test -z "$ac_cpp_err"; then
4958  # Broken: success on invalid input.
4959 continue
4960 else
4961  echo "$as_me: failed program was:" >&5
4962 sed 's/^/| /' conftest.$ac_ext >&5
4963
4964  # Passes both tests.
4965 ac_preproc_ok=:
4966 break
4967 fi
4968 rm -f conftest.err conftest.$ac_ext
4969
4970 done
4971 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4972 rm -f conftest.err conftest.$ac_ext
4973 if $ac_preproc_ok; then
4974  :
4975 else
4976  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
4977 See \`config.log' for more details." >&5
4978 echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
4979 See \`config.log' for more details." >&2;}
4980   { (exit 1); exit 1; }; }
4981 fi
4982
4983 ac_ext=cc
4984 ac_cpp='$CXXCPP $CPPFLAGS'
4985 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4986 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4987 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
4988
4989
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
# Line 5003 | Line 5592 | cat >>conftest.$ac_ext <<_ACEOF
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   {
# Line 5020 | Line 5617 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5617    cat conftest.err >&5
5618    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5619    (exit $ac_status); } &&
5620 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 5149 | Line 5746 | cat >>confdefs.h <<\_ACEOF
5746  
5747   cat >>confdefs.h <<\_ACEOF
5748   #define STDC_HEADERS 1
5152 _ACEOF
5153
5154 fi
5155
5156 echo "$as_me:$LINENO: checking whether the compiler implements namespaces" >&5
5157 echo $ECHO_N "checking whether the compiler implements namespaces... $ECHO_C" >&6
5158 if test "${ac_cv_cxx_namespaces+set}" = set; then
5159  echo $ECHO_N "(cached) $ECHO_C" >&6
5160 else
5161
5162
5163 ac_ext=cc
5164 ac_cpp='$CXXCPP $CPPFLAGS'
5165 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5166 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5167 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5168
5169 cat >conftest.$ac_ext <<_ACEOF
5170 /* confdefs.h.  */
5171 _ACEOF
5172 cat confdefs.h >>conftest.$ac_ext
5173 cat >>conftest.$ac_ext <<_ACEOF
5174 /* end confdefs.h.  */
5175 namespace Outer { namespace Inner { int i = 0; }}
5176 int
5177 main ()
5178 {
5179 using namespace Outer::Inner; return i;
5180  ;
5181  return 0;
5182 }
5183 _ACEOF
5184 rm -f conftest.$ac_objext
5185 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5186  (eval $ac_compile) 2>conftest.er1
5187  ac_status=$?
5188  grep -v '^ *+' conftest.er1 >conftest.err
5189  rm -f conftest.er1
5190  cat conftest.err >&5
5191  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5192  (exit $ac_status); } &&
5193         { ac_try='test -z "$ac_cxx_werror_flag"
5194                         || test ! -s conftest.err'
5195  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5196  (eval $ac_try) 2>&5
5197  ac_status=$?
5198  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5199  (exit $ac_status); }; } &&
5200         { ac_try='test -s conftest.$ac_objext'
5201  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5202  (eval $ac_try) 2>&5
5203  ac_status=$?
5204  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5205  (exit $ac_status); }; }; then
5206  ac_cv_cxx_namespaces=yes
5207 else
5208  echo "$as_me: failed program was:" >&5
5209 sed 's/^/| /' conftest.$ac_ext >&5
5210
5211 ac_cv_cxx_namespaces=no
5212 fi
5213 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5214 ac_ext=cc
5215 ac_cpp='$CXXCPP $CPPFLAGS'
5216 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5217 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5218 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5219
5220
5221 fi
5222 echo "$as_me:$LINENO: result: $ac_cv_cxx_namespaces" >&5
5223 echo "${ECHO_T}$ac_cv_cxx_namespaces" >&6
5224 if test "$ac_cv_cxx_namespaces" = yes; then
5225
5226 cat >>confdefs.h <<\_ACEOF
5227 #define HAVE_NAMESPACES
5749   _ACEOF
5750  
5751   fi
# Line 5267 | Line 5788 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5788    cat conftest.err >&5
5789    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5790    (exit $ac_status); } &&
5791 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 5301 | Line 5822 | done
5822   done
5823  
5824  
5825 < echo "$as_me:$LINENO: checking whether the compiler supports Standard Template Library" >&5
5826 < echo $ECHO_N "checking whether the compiler supports Standard Template Library... $ECHO_C" >&6
5827 < if test "${ac_cv_cxx_have_stl+set}" = set; then
5828 <  echo $ECHO_N "(cached) $ECHO_C" >&6
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 < ac_ext=cc
5855 < ac_cpp='$CXXCPP $CPPFLAGS'
5856 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5857 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5858 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
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 < cat >conftest.$ac_ext <<_ACEOF
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 < #include <list>
5885 < #include <deque>
5886 < #ifdef HAVE_NAMESPACES
5887 < using namespace std;
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 < list<int> x; x.push_back(5);
5333 < list<int>::iterator iter = x.begin(); if (iter != x.end()) ++iter; return 0;
5903 > inflateEnd ();
5904    ;
5905    return 0;
5906   }
5907   _ACEOF
5908 < rm -f conftest.$ac_objext
5909 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5910 <  (eval $ac_compile) 2>conftest.er1
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_cxx_werror_flag"
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_objext'
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_cxx_have_stl=yes
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_cxx_have_stl=no
5366 < fi
5367 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5368 < ac_ext=cc
5369 < ac_cpp='$CXXCPP $CPPFLAGS'
5370 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5371 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5372 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5373 <
5374 <
5935 > ac_cv_lib_z_inflateEnd=no
5936   fi
5937 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_stl" >&5
5938 < echo "${ECHO_T}$ac_cv_cxx_have_stl" >&6
5939 < if test "$ac_cv_cxx_have_stl" = yes; then
5379 <
5380 < cat >>confdefs.h <<\_ACEOF
5381 < #define HAVE_STL
5382 < _ACEOF
5383 <
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 <
5950 <
5951 <  if test "${ac_cv_header_iostream+set}" = set; then
5952 <  echo "$as_me:$LINENO: checking for iostream" >&5
5390 < echo $ECHO_N "checking for iostream... $ECHO_C" >&6
5391 < if test "${ac_cv_header_iostream+set}" = set; then
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_iostream" >&5
5956 < echo "${ECHO_T}$ac_cv_header_iostream" >&6
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 iostream usability" >&5
5960 < echo $ECHO_N "checking iostream usability... $ECHO_C" >&6
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
# Line 5404 | Line 5965 | $ac_includes_default
5965   cat >>conftest.$ac_ext <<_ACEOF
5966   /* end confdefs.h.  */
5967   $ac_includes_default
5968 < #include <iostream>
5968 > #include <zlib.h>
5969   _ACEOF
5970   rm -f conftest.$ac_objext
5971   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5415 | Line 5976 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5976    cat conftest.err >&5
5977    echo "$as_me:$LINENO: \$? = $ac_status" >&5
5978    (exit $ac_status); } &&
5979 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 5440 | Line 6001 | echo "${ECHO_T}$ac_header_compiler" >&6
6001   echo "${ECHO_T}$ac_header_compiler" >&6
6002  
6003   # Is the header present?
6004 < echo "$as_me:$LINENO: checking iostream presence" >&5
6005 < echo $ECHO_N "checking iostream presence... $ECHO_C" >&6
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 <iostream>
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
# Line 5459 | Line 6020 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_cxx_preproc_warn_flag
6024 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
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
# Line 5480 | Line 6041 | echo "${ECHO_T}$ac_header_preproc" >&6
6041   echo "${ECHO_T}$ac_header_preproc" >&6
6042  
6043   # So?  What about this header?
6044 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6044 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6045    yes:no: )
6046 <    { echo "$as_me:$LINENO: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&5
6047 < echo "$as_me: WARNING: iostream: accepted by the compiler, rejected by the preprocessor!" >&2;}
6048 <    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the compiler's result" >&5
6049 < echo "$as_me: WARNING: iostream: proceeding with the compiler's result" >&2;}
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: iostream: present but cannot be compiled" >&5
6054 < echo "$as_me: WARNING: iostream: present but cannot be compiled" >&2;}
6055 <    { echo "$as_me:$LINENO: WARNING: iostream:     check for missing prerequisite headers?" >&5
6056 < echo "$as_me: WARNING: iostream:     check for missing prerequisite headers?" >&2;}
6057 <    { echo "$as_me:$LINENO: WARNING: iostream: see the Autoconf documentation" >&5
6058 < echo "$as_me: WARNING: iostream: see the Autoconf documentation" >&2;}
6059 <    { echo "$as_me:$LINENO: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&5
6060 < echo "$as_me: WARNING: iostream:     section \"Present But Cannot Be Compiled\"" >&2;}
6061 <    { echo "$as_me:$LINENO: WARNING: iostream: proceeding with the preprocessor's result" >&5
6062 < echo "$as_me: WARNING: iostream: proceeding with the preprocessor's result" >&2;}
6063 <    { echo "$as_me:$LINENO: WARNING: iostream: in the future, the compiler will take precedence" >&5
6064 < echo "$as_me: WARNING: iostream: in the future, the compiler will take precedence" >&2;}
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   ## ------------------------------ ##
# Line 5511 | Line 6072 | esac
6072        sed "s/^/$as_me: WARNING:     /" >&2
6073      ;;
6074   esac
6075 < echo "$as_me:$LINENO: checking for iostream" >&5
6076 < echo $ECHO_N "checking for iostream... $ECHO_C" >&6
6077 < if test "${ac_cv_header_iostream+set}" = set; then
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_iostream=$ac_header_preproc
6080 >  ac_cv_header_zlib_h=$ac_header_preproc
6081   fi
6082 < echo "$as_me:$LINENO: result: $ac_cv_header_iostream" >&5
6083 < echo "${ECHO_T}$ac_cv_header_iostream" >&6
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_iostream = yes; then
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_IOSTREAM 1
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 < for ac_header in iostream.h
6175 < do
6176 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6177 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
6178 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
6179 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6180 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
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 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6247 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
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 $ac_header usability" >&5
6269 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
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
# Line 5555 | Line 6274 | $ac_includes_default
6274   cat >>conftest.$ac_ext <<_ACEOF
6275   /* end confdefs.h.  */
6276   $ac_includes_default
6277 < #include <$ac_header>
6277 > #include <fftw3.h>
6278   _ACEOF
6279   rm -f conftest.$ac_objext
6280   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5566 | Line 6285 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6285    cat conftest.err >&5
6286    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6287    (exit $ac_status); } &&
6288 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 5591 | Line 6310 | echo "${ECHO_T}$ac_header_compiler" >&6
6310   echo "${ECHO_T}$ac_header_compiler" >&6
6311  
6312   # Is the header present?
6313 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6314 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
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 <$ac_header>
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
# Line 5610 | Line 6329 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_cxx_preproc_warn_flag
6333 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
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
# Line 5631 | Line 6350 | echo "${ECHO_T}$ac_header_preproc" >&6
6350   echo "${ECHO_T}$ac_header_preproc" >&6
6351  
6352   # So?  What about this header?
6353 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6353 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6354    yes:no: )
6355 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6356 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6357 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6358 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
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: $ac_header: present but cannot be compiled" >&5
6363 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6364 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6365 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6366 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6367 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6368 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6369 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6370 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6371 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6372 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6373 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
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   ## ------------------------------ ##
# Line 5662 | Line 6381 | esac
6381        sed "s/^/$as_me: WARNING:     /" >&2
6382      ;;
6383   esac
6384 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6385 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6386 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
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 <  eval "$as_ac_Header=\$ac_header_preproc"
6389 >  ac_cv_header_fftw3_h=$ac_header_preproc
6390   fi
6391 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6392 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
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 `eval echo '${'$as_ac_Header'}'` = yes; then
6396 <  cat >>confdefs.h <<_ACEOF
6397 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6398 < _ACEOF
5680 <
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  
5683 done
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 < fi
6418 <
6419 <
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_iomanip+set}" = set; then
6482 <  echo "$as_me:$LINENO: checking for iomanip" >&5
6483 < echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
6484 < if test "${ac_cv_header_iomanip+set}" = set; then
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_iomanip" >&5
6488 < echo "${ECHO_T}$ac_cv_header_iomanip" >&6
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 iomanip usability" >&5
6492 < echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
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
# Line 5707 | Line 6497 | $ac_includes_default
6497   cat >>conftest.$ac_ext <<_ACEOF
6498   /* end confdefs.h.  */
6499   $ac_includes_default
6500 < #include <iomanip>
6500 > #include <fftw.h>
6501   _ACEOF
6502   rm -f conftest.$ac_objext
6503   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5718 | Line 6508 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6508    cat conftest.err >&5
6509    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6510    (exit $ac_status); } &&
6511 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 5743 | Line 6533 | echo "${ECHO_T}$ac_header_compiler" >&6
6533   echo "${ECHO_T}$ac_header_compiler" >&6
6534  
6535   # Is the header present?
6536 < echo "$as_me:$LINENO: checking iomanip presence" >&5
6537 < echo $ECHO_N "checking iomanip presence... $ECHO_C" >&6
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 <iomanip>
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
# Line 5762 | Line 6552 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_cxx_preproc_warn_flag
6556 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
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
# Line 5783 | Line 6573 | echo "${ECHO_T}$ac_header_preproc" >&6
6573   echo "${ECHO_T}$ac_header_preproc" >&6
6574  
6575   # So?  What about this header?
6576 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6576 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6577    yes:no: )
6578 <    { echo "$as_me:$LINENO: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&5
6579 < echo "$as_me: WARNING: iomanip: accepted by the compiler, rejected by the preprocessor!" >&2;}
6580 <    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the compiler's result" >&5
6581 < echo "$as_me: WARNING: iomanip: proceeding with the compiler's result" >&2;}
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: iomanip: present but cannot be compiled" >&5
6586 < echo "$as_me: WARNING: iomanip: present but cannot be compiled" >&2;}
6587 <    { echo "$as_me:$LINENO: WARNING: iomanip:     check for missing prerequisite headers?" >&5
6588 < echo "$as_me: WARNING: iomanip:     check for missing prerequisite headers?" >&2;}
6589 <    { echo "$as_me:$LINENO: WARNING: iomanip: see the Autoconf documentation" >&5
6590 < echo "$as_me: WARNING: iomanip: see the Autoconf documentation" >&2;}
6591 <    { echo "$as_me:$LINENO: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&5
6592 < echo "$as_me: WARNING: iomanip:     section \"Present But Cannot Be Compiled\"" >&2;}
6593 <    { echo "$as_me:$LINENO: WARNING: iomanip: proceeding with the preprocessor's result" >&5
6594 < echo "$as_me: WARNING: iomanip: proceeding with the preprocessor's result" >&2;}
6595 <    { echo "$as_me:$LINENO: WARNING: iomanip: in the future, the compiler will take precedence" >&5
6596 < echo "$as_me: WARNING: iomanip: in the future, the compiler will take precedence" >&2;}
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   ## ------------------------------ ##
# Line 5814 | Line 6604 | esac
6604        sed "s/^/$as_me: WARNING:     /" >&2
6605      ;;
6606   esac
6607 < echo "$as_me:$LINENO: checking for iomanip" >&5
6608 < echo $ECHO_N "checking for iomanip... $ECHO_C" >&6
6609 < if test "${ac_cv_header_iomanip+set}" = set; then
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_iomanip=$ac_header_preproc
6612 >  ac_cv_header_fftw_h=$ac_header_preproc
6613   fi
6614 < echo "$as_me:$LINENO: result: $ac_cv_header_iomanip" >&5
6615 < echo "${ECHO_T}$ac_cv_header_iomanip" >&6
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_iomanip = yes; then
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 < cat >>confdefs.h <<\_ACEOF
6626 < #define HAVE_IOMANIP 1
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 <
6705 < for ac_header in iomanip.h
6706 < do
6707 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
5842 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
5843 <  echo "$as_me:$LINENO: checking for $ac_header" >&5
5844 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
5845 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
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: `eval echo '${'$as_ac_Header'}'`" >&5
6711 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
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 $ac_header usability" >&5
6715 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
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
# Line 5858 | Line 6720 | $ac_includes_default
6720   cat >>conftest.$ac_ext <<_ACEOF
6721   /* end confdefs.h.  */
6722   $ac_includes_default
6723 < #include <$ac_header>
6723 > #include <dfftw.h>
6724   _ACEOF
6725   rm -f conftest.$ac_objext
6726   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 5869 | Line 6731 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6731    cat conftest.err >&5
6732    echo "$as_me:$LINENO: \$? = $ac_status" >&5
6733    (exit $ac_status); } &&
6734 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 5894 | Line 6756 | echo "${ECHO_T}$ac_header_compiler" >&6
6756   echo "${ECHO_T}$ac_header_compiler" >&6
6757  
6758   # Is the header present?
6759 < echo "$as_me:$LINENO: checking $ac_header presence" >&5
6760 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
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 <$ac_header>
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
# Line 5913 | Line 6775 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_cxx_preproc_warn_flag
6779 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
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
# Line 5934 | Line 6796 | echo "${ECHO_T}$ac_header_preproc" >&6
6796   echo "${ECHO_T}$ac_header_preproc" >&6
6797  
6798   # So?  What about this header?
6799 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
6799 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6800    yes:no: )
6801 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6802 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
6803 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
6804 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
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: $ac_header: present but cannot be compiled" >&5
6809 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
6810 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
6811 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
6812 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
6813 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
6814 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
6815 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
6816 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
6817 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
6818 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
6819 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
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   ## ------------------------------ ##
# Line 5965 | Line 6827 | esac
6827        sed "s/^/$as_me: WARNING:     /" >&2
6828      ;;
6829   esac
6830 < echo "$as_me:$LINENO: checking for $ac_header" >&5
6831 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6832 < if eval "test \"\${$as_ac_Header+set}\" = set"; then
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 <  eval "$as_ac_Header=\$ac_header_preproc"
6835 >  ac_cv_header_dfftw_h=$ac_header_preproc
6836   fi
6837 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6838 < echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
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 `eval echo '${'$as_ac_Header'}'` = yes; then
6842 <  cat >>confdefs.h <<_ACEOF
6843 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
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  
5986 done
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 < for ac_header in cmath
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
# Line 6024 | Line 7147 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7147    cat conftest.err >&5
7148    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7149    (exit $ac_status); } &&
7150 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 6068 | Line 7191 | if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$a
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_cxx_preproc_warn_flag
7195 <    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
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
# Line 6089 | Line 7212 | echo "${ECHO_T}$ac_header_preproc" >&6
7212   echo "${ECHO_T}$ac_header_preproc" >&6
7213  
7214   # So?  What about this header?
7215 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
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;}
# Line 6141 | Line 7264 | done
7264   done
7265  
7266  
7267 <
7268 <
7269 <  echo "$as_me:$LINENO: checking for C++ iostream in namespace std" >&5
7270 < echo $ECHO_N "checking for C++ iostream in namespace std... $ECHO_C" >&6
6148 < if test "${ac_cv_cxx_have_std_iostream+set}" = set; then
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 <
6152 <      ac_cv_cxx_have_std_iostream=no
6153 <      ac_cv_cxx_need_use_std_iostream=no
6154 <      if test "x$ac_cv_cxx_namespaces" = xyes; then
6155 <
6156 <
6157 <        ac_ext=cc
6158 < ac_cpp='$CXXCPP $CPPFLAGS'
6159 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6160 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6161 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6162 <
6163 <        cat >conftest.$ac_ext <<_ACEOF
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 < #ifdef HAVE_IOSTREAM
7281 < #include <iostream>
7282 < #else
6173 < #include <iostream.h>
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 < std::cout<<"Hello World"<<std::endl;return 0;
7323 > return !a + !b + !c + !d + !e + !f + !g + !h + !i;
7324    ;
7325    return 0;
7326   }
# Line 6190 | Line 7334 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7334    cat conftest.err >&5
7335    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7336    (exit $ac_status); } &&
7337 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 6203 | Line 7347 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7347    ac_status=$?
7348    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7349    (exit $ac_status); }; }; then
7350 <  ac_cv_cxx_have_std_iostream=yes
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 <        cat >conftest.$ac_ext <<_ACEOF
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 <
7373 < #define __USE_STD_IOSTREAM 1
7374 < #ifdef HAVE_IOSTREAM
7375 < #include <iostream>
7376 < #else
7377 < #include <iostream.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 <
7380 > #endif
7381   int
7382   main ()
7383   {
7384 < std::cout<<"Hello World"<<std::endl;return 0;
7384 > if ((_Bool *) 0)
7385 >  return 0;
7386 > if (sizeof (_Bool))
7387 >  return 0;
7388    ;
7389    return 0;
7390   }
# Line 6241 | Line 7398 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7398    cat conftest.err >&5
7399    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7400    (exit $ac_status); } &&
7401 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 6254 | Line 7411 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7411    ac_status=$?
7412    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7413    (exit $ac_status); }; }; then
7414 <  ac_cv_cxx_have_std_iostream=yes;ac_cv_cxx_need_use_std_iostream=yes
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
6264        ac_ext=cc
6265 ac_cpp='$CXXCPP $CPPFLAGS'
6266 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6267 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6268 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6269
6270      fi
6271
7422   fi
7423 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_iostream" >&5
7424 < echo "${ECHO_T}$ac_cv_cxx_have_std_iostream" >&6
7425 <  if test "$ac_cv_cxx_have_std_iostream" = yes; then
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_STD_IOSTREAM 1
7427 > cat >>confdefs.h <<_ACEOF
7428 > #define HAVE__BOOL 1
7429   _ACEOF
7430  
6281  fi
6282  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
7431  
7432 + fi
7433 +
7434 + if test $ac_cv_header_stdbool_h = yes; then
7435 +
7436   cat >>confdefs.h <<\_ACEOF
7437 < #define __USE_STD_IOSTREAM 1
7437 > #define HAVE_STDBOOL_H 1
7438   _ACEOF
7439  
7440 <  fi
7440 > fi
7441  
7442 <
7443 <
7444 <
6293 <  echo "$as_me:$LINENO: checking for C++ Standard Template Library in namespace std." >&5
6294 < echo $ECHO_N "checking for C++ Standard Template Library in namespace std.... $ECHO_C" >&6
6295 < if test "${ac_cv_cxx_have_std_stl+set}" = set; then
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 <
6299 <      ac_cv_cxx_have_std_stl=no
6300 <      if test "x$ac_cv_cxx_namespaces" = xyes; then
6301 <
6302 <
6303 <        ac_ext=cc
6304 < ac_cpp='$CXXCPP $CPPFLAGS'
6305 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6306 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6307 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6308 <
6309 <        cat >conftest.$ac_ext <<_ACEOF
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.  */
6315 #include <list>
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 < std::list<int> foo;return 0;
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   }
# Line 6331 | Line 7522 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7522    cat conftest.err >&5
7523    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7524    (exit $ac_status); } &&
7525 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 6344 | Line 7535 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7535    ac_status=$?
7536    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7537    (exit $ac_status); }; }; then
7538 <  ac_cv_cxx_have_std_stl=yes
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
6354        ac_ext=cc
6355 ac_cpp='$CXXCPP $CPPFLAGS'
6356 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6357 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6358 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6359
6360      fi
6361
7546   fi
7547 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_std_stl" >&5
7548 < echo "${ECHO_T}$ac_cv_cxx_have_std_stl" >&6
7549 <  if test "$ac_cv_cxx_have_std_stl" = yes; then
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 HAVE_STD_STL 1
7552 > #define const
7553   _ACEOF
7554  
7555 <  fi
7555 > fi
7556  
7557 <
7558 <
7559 <  echo "$as_me:$LINENO: checking for fstream::attach()" >&5
6376 < echo $ECHO_N "checking for fstream::attach()... $ECHO_C" >&6
6377 < if test "${ac_cv_cxx_have_fstream_attach+set}" = set; then
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 <
7563 <    ac_cv_cxx_have_fstream_attach=no
7564 <
6383 <
6384 <    ac_ext=cc
6385 < ac_cpp='$CXXCPP $CPPFLAGS'
6386 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6387 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6388 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6389 <
6390 <    cat >conftest.$ac_ext <<_ACEOF
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 <
7571 < #ifdef HAVE_IOSTREAM
7572 < #include <fstream>
7573 < #else
6400 < #include <fstream.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
6402 #ifdef HAVE_STD_IOSTREAM
6403 using namespace std;
6404 #endif
7575  
6406 int
6407 main ()
6408 {
6409 int fd=0;ofstream s;s.attach(fd);
6410  ;
6411  return 0;
6412 }
7576   _ACEOF
7577   rm -f conftest.$ac_objext
7578   if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
# Line 6420 | Line 7583 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7583    cat conftest.err >&5
7584    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7585    (exit $ac_status); } &&
7586 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 6433 | Line 7596 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7596    ac_status=$?
7597    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7598    (exit $ac_status); }; }; then
7599 <  ac_cv_cxx_have_fstream_attach=yes
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 <    ac_ext=cc
6444 < ac_cpp='$CXXCPP $CPPFLAGS'
6445 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6446 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6447 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
7606 > done
7607  
6449
7608   fi
7609 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_attach" >&5
7610 < echo "${ECHO_T}$ac_cv_cxx_have_fstream_attach" >&6
6453 <  if test "$ac_cv_cxx_have_fstream_attach" = yes; then
7609 > echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
7610 > echo "${ECHO_T}$ac_cv_c_inline" >&6
7611  
7612 < cat >>confdefs.h <<\_ACEOF
7613 < #define HAVE_FSTREAM_ATTACH 1
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 <  fi
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 fstream::open()" >&5
7693 < echo $ECHO_N "checking for fstream::open()... $ECHO_C" >&6
7694 < if test "${ac_cv_cxx_have_fstream_open+set}" = set; then
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 <
6469 <    ac_cv_cxx_have_fstream_open=no
6470 <    ac_cv_cxx_fstream_open_prot=no
6471 <
6472 <
6473 <    ac_ext=cc
6474 < ac_cpp='$CXXCPP $CPPFLAGS'
6475 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6476 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6477 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6478 <
6479 <    # Try with 2 parameters
6480 <    cat >conftest.$ac_ext <<_ACEOF
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 <
7704 < #ifdef HAVE_IOSTREAM
7705 < #include <fstream>
7706 < #else
7707 < #include <fstream.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
6492 #ifdef HAVE_STD_IOSTREAM
6493 using namespace std;
7711   #endif
6495
7712   int
7713   main ()
7714   {
7715 < ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
7715 > if ((size_t *) 0)
7716 >  return 0;
7717 > if (sizeof (size_t))
7718 >  return 0;
7719    ;
7720    return 0;
7721   }
# Line 6510 | Line 7729 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7729    cat conftest.err >&5
7730    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7731    (exit $ac_status); } &&
7732 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 6523 | Line 7742 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7742    ac_status=$?
7743    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7744    (exit $ac_status); }; }; then
7745 <  ac_cv_cxx_have_fstream_open=yes
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 <    # Try with mode parameter
7754 <    cat >conftest.$ac_ext <<_ACEOF
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 HAVE_IOSTREAM
7782 < #include <fstream>
7783 < #else
7784 < #include <fstream.h>
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
6546 #ifdef HAVE_STD_IOSTREAM
6547 using namespace std;
7788   #endif
6549
7789   int
7790   main ()
7791   {
7792 < ofstream s;s.open("conftest.txt",ios::out|ios::trunc,0666);
7792 > if ((struct tm *) 0)
7793 > return 0;
7794    ;
7795    return 0;
7796   }
# Line 6564 | Line 7804 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7804    cat conftest.err >&5
7805    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7806    (exit $ac_status); } &&
7807 <         { ac_try='test -z "$ac_cxx_werror_flag"
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
# Line 6577 | Line 7817 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
7817    ac_status=$?
7818    echo "$as_me:$LINENO: \$? = $ac_status" >&5
7819    (exit $ac_status); }; }; then
7820 <  ac_cv_cxx_fstream_open_prot=yes
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
6587    ac_ext=cc
6588 ac_cpp='$CXXCPP $CPPFLAGS'
6589 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6590 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6591 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6592
6593
7828   fi
7829 < echo "$as_me:$LINENO: result: $ac_cv_cxx_have_fstream_open" >&5
7830 < echo "${ECHO_T}$ac_cv_cxx_have_fstream_open" >&6
7831 <  if test "$ac_cv_cxx_have_fstream_open" = yes; then
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 HAVE_FSTREAM_OPEN 1
7834 > #define TIME_WITH_SYS_TIME 1
7835   _ACEOF
7836  
7837 <  fi
6604 <  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
7837 > fi
7838  
7839 < cat >>confdefs.h <<\_ACEOF
7840 < #define FSTREAM_OPEN_PROT 1
7841 < _ACEOF
6609 <
6610 <  fi
6611 <
6612 <
6613 <
6614 <
6615 < echo "$as_me:$LINENO: checking for asin in -lm" >&5
6616 < echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6
6617 < if test "${ac_cv_lib_m_asin+set}" = set; then
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 <  ac_check_lib_save_LIBS=$LIBS
6621 < LIBS="-lm  $LIBS"
6622 < cat >conftest.$ac_ext <<_ACEOF
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 <
7851 < /* Override any gcc2 internal prototype to avoid an error.  */
7852 < #ifdef __cplusplus
7853 < extern "C"
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 < /* We use char because int might match the return type of a gcc2
6634 <   builtin and then its argument prototype would still apply.  */
6635 < char asin ();
7858 > #endif
7859   int
7860   main ()
7861   {
7862 < asin ();
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 conftest$ac_exeext
7871 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7872 <  (eval $ac_link) 2>conftest.er1
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_cxx_werror_flag"
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_exeext'
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_lib_m_asin=yes
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_lib_m_asin=no
7897 > ac_cv_type_clock_t=no
7898   fi
7899 < rm -f conftest.err conftest.$ac_objext \
6674 <      conftest$ac_exeext conftest.$ac_ext
6675 < LIBS=$ac_check_lib_save_LIBS
7899 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
7900   fi
7901 < echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
7902 < echo "${ECHO_T}$ac_cv_lib_m_asin" >&6
7903 < if test $ac_cv_lib_m_asin = yes; then
7904 <  cat >>confdefs.h <<_ACEOF
7905 < #define HAVE_LIBM 1
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  
6684  LIBS="-lm $LIBS"
7909  
6686 else
6687  exit
7910   fi
7911  
7912 <
7913 <
7914 < #
6693 < # Handle user hints
6694 < #
6695 < echo "$as_me:$LINENO: checking if zlib is wanted" >&5
6696 < echo $ECHO_N "checking if zlib is wanted... $ECHO_C" >&6
6697 <
6698 < # Check whether --with-zlib or --without-zlib was given.
6699 < if test "${with_zlib+set}" = set; then
6700 <  withval="$with_zlib"
6701 <  if test "$withval" != no ; then
6702 <  echo "$as_me:$LINENO: result: yes" >&5
6703 < echo "${ECHO_T}yes" >&6
6704 <  if test -d "$withval"
6705 <  then
6706 <    ZLIB_HOME="$withval"
6707 <  else
6708 <    { echo "$as_me:$LINENO: WARNING: Sorry, $withval does not exist, checking usual places" >&5
6709 < echo "$as_me: WARNING: Sorry, $withval does not exist, checking usual places" >&2;}
6710 <  fi
6711 < else
6712 <  echo "$as_me:$LINENO: result: no" >&5
6713 < echo "${ECHO_T}no" >&6
6714 < fi
6715 < fi;
6716 <
6717 < ZLIB_HOME=/usr/local
6718 < if test ! -f "${ZLIB_HOME}/include/zlib.h"
6719 < then
6720 <        ZLIB_HOME=/usr
6721 < fi
6722 <
6723 < #
6724 < # Locate zlib, if wanted
6725 < #
6726 < if test -n "${ZLIB_HOME}"
6727 < then
6728 <        ZLIB_OLD_LDFLAGS=$LDFLAGS
6729 <        ZLIB_OLD_CPPFLAGS=$LDFLAGS
6730 <        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
6731 <        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
6732 <
6733 <
6734 <        ac_ext=c
6735 < ac_cpp='$CPP $CPPFLAGS'
6736 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6737 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6738 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6739 <
6740 <        echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
6741 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
6742 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
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 <  ac_check_lib_save_LIBS=$LIBS
6746 < LIBS="-lz  $LIBS"
6747 < cat >conftest.$ac_ext <<_ACEOF
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 < /* Override any gcc2 internal prototype to avoid an error.  */
7925 < #ifdef __cplusplus
7926 < extern "C"
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 < /* We use char because int might match the return type of a gcc2
6759 <   builtin and then its argument prototype would still apply.  */
6760 < char inflateEnd ();
7931 > #endif
7932   int
7933   main ()
7934   {
7935 < inflateEnd ();
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 conftest$ac_exeext
7987 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7988 <  (eval $ac_link) 2>conftest.er1
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
# Line 6782 | Line 7999 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
7999    ac_status=$?
8000    echo "$as_me:$LINENO: \$? = $ac_status" >&5
8001    (exit $ac_status); }; } &&
8002 <         { ac_try='test -s conftest$ac_exeext'
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_lib_z_inflateEnd=yes
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_lib_z_inflateEnd=no
8013 > ac_cv_c_const=no
8014   fi
8015 < rm -f conftest.err conftest.$ac_objext \
6799 <      conftest$ac_exeext conftest.$ac_ext
6800 < LIBS=$ac_check_lib_save_LIBS
8015 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8016   fi
8017 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
8018 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
8019 < if test $ac_cv_lib_z_inflateEnd = yes; then
8020 <  zlib_cv_libz=yes
8021 < else
8022 <  zlib_cv_libz=no
8023 < fi
8024 <
8025 <        if test "${ac_cv_header_zlib_h+set}" = set; then
8026 <  echo "$as_me:$LINENO: checking for zlib.h" >&5
8027 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
8028 < if test "${ac_cv_header_zlib_h+set}" = set; then
8029 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8030 < fi
8031 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
8032 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
8033 < else
8034 <  # Is the header compilable?
8035 < echo "$as_me:$LINENO: checking zlib.h usability" >&5
8036 < echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6
8037 < cat >conftest.$ac_ext <<_ACEOF
8038 < /* confdefs.h.  */
8039 < _ACEOF
8040 < cat confdefs.h >>conftest.$ac_ext
8041 < cat >>conftest.$ac_ext <<_ACEOF
8042 < /* end confdefs.h.  */
8043 < $ac_includes_default
8044 < #include <zlib.h>
8045 < _ACEOF
8046 < rm -f conftest.$ac_objext
8047 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8048 <  (eval $ac_compile) 2>conftest.er1
8049 <  ac_status=$?
8050 <  grep -v '^ *+' conftest.er1 >conftest.err
8051 <  rm -f conftest.er1
8052 <  cat conftest.err >&5
8053 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8054 <  (exit $ac_status); } &&
8055 <         { ac_try='test -z "$ac_c_werror_flag"
8056 <                         || test ! -s conftest.err'
8057 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8058 <  (eval $ac_try) 2>&5
8059 <  ac_status=$?
8060 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8061 <  (exit $ac_status); }; } &&
8062 <         { ac_try='test -s conftest.$ac_objext'
8063 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8064 <  (eval $ac_try) 2>&5
8065 <  ac_status=$?
8066 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8067 <  (exit $ac_status); }; }; then
8068 <  ac_header_compiler=yes
8069 < else
8070 <  echo "$as_me: failed program was:" >&5
8071 < sed 's/^/| /' conftest.$ac_ext >&5
8072 <
8073 < ac_header_compiler=no
8074 < fi
8075 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
8076 < echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8077 < echo "${ECHO_T}$ac_header_compiler" >&6
8078 <
8079 < # Is the header present?
8080 < echo "$as_me:$LINENO: checking zlib.h presence" >&5
8081 < echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6
8082 < cat >conftest.$ac_ext <<_ACEOF
8083 < /* confdefs.h.  */
8084 < _ACEOF
8085 < cat confdefs.h >>conftest.$ac_ext
8086 < cat >>conftest.$ac_ext <<_ACEOF
8087 < /* end confdefs.h.  */
8088 < #include <zlib.h>
8089 < _ACEOF
8090 < if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
8091 <  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
8092 <  ac_status=$?
8093 <  grep -v '^ *+' conftest.er1 >conftest.err
8094 <  rm -f conftest.er1
8095 <  cat conftest.err >&5
8096 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8097 <  (exit $ac_status); } >/dev/null; then
8098 <  if test -s conftest.err; then
8099 <    ac_cpp_err=$ac_c_preproc_warn_flag
8100 <    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8101 <  else
8102 <    ac_cpp_err=
8103 <  fi
8104 < else
8105 <  ac_cpp_err=yes
8106 < fi
8107 < if test -z "$ac_cpp_err"; then
8108 <  ac_header_preproc=yes
8109 < else
8110 <  echo "$as_me: failed program was:" >&5
8111 < sed 's/^/| /' conftest.$ac_ext >&5
8112 <
8113 <  ac_header_preproc=no
8114 < fi
8115 < rm -f conftest.err conftest.$ac_ext
8116 < echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8117 < echo "${ECHO_T}$ac_header_preproc" >&6
8118 <
8119 < # So?  What about this header?
8120 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8121 <  yes:no: )
8122 <    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
8123 < echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8124 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
8125 < echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
8126 <    ac_header_preproc=yes
8127 <    ;;
8128 <  no:yes:* )
8129 <    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
8130 < echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
8131 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
8132 < echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
8133 <    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
8134 < echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
8135 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
8136 < echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
8137 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
8138 < echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
8139 <    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
8140 < echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
8141 <    (
8142 <      cat <<\_ASBOX
8143 < ## ------------------------------ ##
8144 < ## Report this to gezelter@nd.edu ##
8145 < ## ------------------------------ ##
8146 < _ASBOX
8147 <    ) |
8148 <      sed "s/^/$as_me: WARNING:     /" >&2
8149 <    ;;
8150 < esac
8151 < echo "$as_me:$LINENO: checking for zlib.h" >&5
8152 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6
8153 < if test "${ac_cv_header_zlib_h+set}" = set; then
8154 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8155 < else
8156 <  ac_cv_header_zlib_h=$ac_header_preproc
8157 < fi
8158 < echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
8159 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6
8160 <
8161 < fi
8162 < if test $ac_cv_header_zlib_h = yes; then
8163 <  zlib_cv_zlib_h=yes
8164 < else
8165 <  zlib_cv_zlib_h=no
8166 < fi
8167 <
8168 <
8169 <        ac_ext=cc
8170 < ac_cpp='$CXXCPP $CPPFLAGS'
8171 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8172 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8173 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
8174 <
8175 <        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"
8176 <        then
8177 <                #
8178 <                # If both library and header were found, use them
8179 <                #
8180 <
8181 < echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
8182 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6
8183 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
8184 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8185 < else
8186 <  ac_check_lib_save_LIBS=$LIBS
8187 < LIBS="-lz  $LIBS"
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_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_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_header_compiler=yes
8476 > else
8477 >  echo "$as_me: failed program was:" >&5
8478 > sed 's/^/| /' conftest.$ac_ext >&5
8479 >
8480 > ac_header_compiler=no
8481 > fi
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 > # 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 > #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
8499 >  ac_status=$?
8500 >  grep -v '^ *+' conftest.er1 >conftest.err
8501 >  rm -f conftest.er1
8502 >  cat conftest.err >&5
8503 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8504 >  (exit $ac_status); } >/dev/null; then
8505 >  if test -s conftest.err; then
8506 >    ac_cpp_err=$ac_c_preproc_warn_flag
8507 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8508 >  else
8509 >    ac_cpp_err=
8510 >  fi
8511 > else
8512 >  ac_cpp_err=yes
8513 > fi
8514 > if test -z "$ac_cpp_err"; then
8515 >  ac_header_preproc=yes
8516 > else
8517 >  echo "$as_me: failed program was:" >&5
8518 > sed 's/^/| /' conftest.$ac_ext >&5
8519 >
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 > # 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 > #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 > rm -f conftest$ac_exeext
8615 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
8616 >  (eval $ac_link) 2>&5
8617 >  ac_status=$?
8618 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
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 >  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 > ( exit $ac_status )
8632 > ac_cv_func_realloc_0_nonnull=no
8633 > fi
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 > cat >>confdefs.h <<\_ACEOF
8642 > #define HAVE_REALLOC 1
8643 > _ACEOF
8644 >
8645 > else
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 >
8665 >
8666 >
8667 >
8668 >
8669 > for ac_header in sys/select.h sys/socket.h
8670 > do
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 > $ac_includes_default
8691 > #include <$ac_header>
8692 > _ACEOF
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); } &&
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
8717 >  echo "$as_me: failed program was:" >&5
8718 > sed 's/^/| /' conftest.$ac_ext >&5
8719 >
8720 > ac_header_compiler=no
8721 > fi
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 > # 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_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
8739 >  ac_status=$?
8740 >  grep -v '^ *+' conftest.er1 >conftest.err
8741 >  rm -f conftest.er1
8742 >  cat conftest.err >&5
8743 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8744 >  (exit $ac_status); } >/dev/null; then
8745 >  if test -s conftest.err; then
8746 >    ac_cpp_err=$ac_c_preproc_warn_flag
8747 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
8748 >  else
8749 >    ac_cpp_err=
8750 >  fi
8751 > else
8752 >  ac_cpp_err=yes
8753 > fi
8754 > if test -z "$ac_cpp_err"; then
8755 >  ac_header_preproc=yes
8756 > else
8757 >  echo "$as_me: failed program was:" >&5
8758 > sed 's/^/| /' conftest.$ac_ext >&5
8759 >
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 > # 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 >  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 > 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 >
8814 > fi
8815 >
8816 > done
8817 >
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 >  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 > $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 > extern int select ($ac_arg1,
8852 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
8853 >                                            $ac_arg5);
8854 >  ;
8855 >  return 0;
8856 > }
8857 > _ACEOF
8858 > rm -f conftest.$ac_objext
8859 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
8860 >  (eval $ac_compile) 2>conftest.er1
8861 >  ac_status=$?
8862 >  grep -v '^ *+' conftest.er1 >conftest.err
8863 >  rm -f conftest.er1
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"
8868 >                         || test ! -s conftest.err'
8869 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8870 >  (eval $ac_try) 2>&5
8871 >  ac_status=$?
8872 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8873 >  (exit $ac_status); }; } &&
8874 >         { ac_try='test -s conftest.$ac_objext'
8875 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
8876 >  (eval $ac_try) 2>&5
8877 >  ac_status=$?
8878 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8879 >  (exit $ac_status); }; }; then
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 >
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 > 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 > /* 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 > 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 >  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 > 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.  */
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 > 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 >  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.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 > 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 >  ac_cv_func_strtod=no
9116 > else
9117 >  cat >conftest.$ac_ext <<_ACEOF
9118 > /* confdefs.h.  */
9119 > _ACEOF
9120 > cat confdefs.h >>conftest.$ac_ext
9121 > cat >>conftest.$ac_ext <<_ACEOF
9122 > /* end confdefs.h.  */
9123 >
9124 > double strtod ();
9125 > int
9126 > main()
9127 > {
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
9153 >  (eval $ac_link) 2>&5
9154 >  ac_status=$?
9155 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9156 >  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9157 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9158 >  (eval $ac_try) 2>&5
9159 >  ac_status=$?
9160 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9161 >  (exit $ac_status); }; }; then
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_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 > 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 > 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 > /* 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 > #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 > 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 >  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.  */
9298 >
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 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"
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_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 >  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 > ac_cv_lib_m_pow=no
9350 > fi
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: $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 > fi
9367 >
9368 >
9369 >
9370 >
9371 >
9372 >
9373 >
9374 >
9375 >
9376 >
9377 >
9378 >
9379 >
9380 >
9381 >
9382 >
9383 >
9384 >
9385 >
9386 >
9387 >
9388 >
9389 >
9390 >
9391 >
9392 >
9393 >
9394 >
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 >  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 $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 > return f != $ac_func;
9458 >  ;
9459 >  return 0;
9460 > }
9461 > _ACEOF
9462 > rm -f conftest.$ac_objext conftest$ac_exeext
9463 > if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9464 >  (eval $ac_link) 2>conftest.er1
9465 >  ac_status=$?
9466 >  grep -v '^ *+' conftest.er1 >conftest.err
9467 >  rm -f conftest.er1
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"
9472 >                         || test ! -s conftest.err'
9473 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9474 >  (eval $ac_try) 2>&5
9475 >  ac_status=$?
9476 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9477 >  (exit $ac_status); }; } &&
9478 >         { ac_try='test -s conftest$ac_exeext'
9479 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9480 >  (eval $ac_try) 2>&5
9481 >  ac_status=$?
9482 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9483 >  (exit $ac_status); }; }; then
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 > eval "$as_ac_var=no"
9490 > fi
9491 > rm -f conftest.err conftest.$ac_objext \
9492 >      conftest$ac_exeext conftest.$ac_ext
9493 > fi
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
9500 >
9501 > fi
9502 > done
9503 >
9504 >
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 > #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 > #endif
9524 > int
9525 > main ()
9526 > {
9527 > double x = _system_configuration.physmem;
9528 >  ;
9529 >  return 0;
9530 > }
9531 > _ACEOF
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"
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_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 >  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 > echo "$as_me:$LINENO: result: no" >&5
9566 > echo "${ECHO_T}no" >&6
9567 > fi
9568 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9569 >
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 > 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
9578 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
9579 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9580 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9581 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9582 > fi
9583 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9584 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9585 > else
9586 >  # Is the header compilable?
9587 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
9588 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
9589 > cat >conftest.$ac_ext <<_ACEOF
9590 > /* confdefs.h.  */
9591 > _ACEOF
9592 > cat confdefs.h >>conftest.$ac_ext
9593 > cat >>conftest.$ac_ext <<_ACEOF
9594 > /* end confdefs.h.  */
9595 > $ac_includes_default
9596 > #include <$ac_header>
9597 > _ACEOF
9598 > rm -f conftest.$ac_objext
9599 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9600 >  (eval $ac_compile) 2>conftest.er1
9601 >  ac_status=$?
9602 >  grep -v '^ *+' conftest.er1 >conftest.err
9603 >  rm -f conftest.er1
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"
9608 >                         || test ! -s conftest.err'
9609 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9610 >  (eval $ac_try) 2>&5
9611 >  ac_status=$?
9612 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9613 >  (exit $ac_status); }; } &&
9614 >         { ac_try='test -s conftest.$ac_objext'
9615 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9616 >  (eval $ac_try) 2>&5
9617 >  ac_status=$?
9618 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9619 >  (exit $ac_status); }; }; then
9620 >  ac_header_compiler=yes
9621 > else
9622 >  echo "$as_me: failed program was:" >&5
9623 > sed 's/^/| /' conftest.$ac_ext >&5
9624 >
9625 > ac_header_compiler=no
9626 > fi
9627 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9628 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9629 > echo "${ECHO_T}$ac_header_compiler" >&6
9630 >
9631 > # Is the header present?
9632 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
9633 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
9634 > cat >conftest.$ac_ext <<_ACEOF
9635 > /* confdefs.h.  */
9636 > _ACEOF
9637 > cat confdefs.h >>conftest.$ac_ext
9638 > cat >>conftest.$ac_ext <<_ACEOF
9639 > /* end confdefs.h.  */
9640 > #include <$ac_header>
9641 > _ACEOF
9642 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
9643 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
9644 >  ac_status=$?
9645 >  grep -v '^ *+' conftest.er1 >conftest.err
9646 >  rm -f conftest.er1
9647 >  cat conftest.err >&5
9648 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9649 >  (exit $ac_status); } >/dev/null; then
9650 >  if test -s conftest.err; then
9651 >    ac_cpp_err=$ac_c_preproc_warn_flag
9652 >    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
9653 >  else
9654 >    ac_cpp_err=
9655 >  fi
9656 > else
9657 >  ac_cpp_err=yes
9658 > fi
9659 > if test -z "$ac_cpp_err"; then
9660 >  ac_header_preproc=yes
9661 > else
9662 >  echo "$as_me: failed program was:" >&5
9663 > sed 's/^/| /' conftest.$ac_ext >&5
9664 >
9665 >  ac_header_preproc=no
9666 > fi
9667 > rm -f conftest.err conftest.$ac_ext
9668 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9669 > echo "${ECHO_T}$ac_header_preproc" >&6
9670 >
9671 > # So?  What about this header?
9672 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9673 >  yes:no: )
9674 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9675 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9676 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9677 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9678 >    ac_header_preproc=yes
9679 >    ;;
9680 >  no:yes:* )
9681 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9682 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9683 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9684 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9685 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9686 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9687 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9688 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9689 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9690 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9691 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9692 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
9693 >    (
9694 >      cat <<\_ASBOX
9695 > ## ------------------------------ ##
9696 > ## Report this to gezelter@nd.edu ##
9697 > ## ------------------------------ ##
9698 > _ASBOX
9699 >    ) |
9700 >      sed "s/^/$as_me: WARNING:     /" >&2
9701 >    ;;
9702 > esac
9703 > echo "$as_me:$LINENO: checking for $ac_header" >&5
9704 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
9705 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
9706 >  echo $ECHO_N "(cached) $ECHO_C" >&6
9707 > else
9708 >  eval "$as_ac_Header=\$ac_header_preproc"
9709 > fi
9710 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
9711 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
9712 >
9713 > fi
9714 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
9715 >  cat >>confdefs.h <<_ACEOF
9716 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
9717 > _ACEOF
9718 >
9719 > fi
9720 >
9721 > done
9722 >
9723 >
9724 > for ac_func in getopt_long
9725 > do
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
9731 > else
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 > /* 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 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"
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_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 >  eval "$as_ac_var=yes"
9814 > else
9815 >  echo "$as_me: failed program was:" >&5
9816 > sed 's/^/| /' conftest.$ac_ext >&5
9817 >
9818 > eval "$as_ac_var=no"
9819 > fi
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 > 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 >
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 > 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); } &&
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
9893 >  echo "$as_me: failed program was:" >&5
9894 > sed 's/^/| /' conftest.$ac_ext >&5
9895 >
9896 > ac_cv_lib_gnugetopt_getopt_long=no
9897 > fi
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 >
9909 > else
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 >      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'
10029 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10030 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10031 > echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
10032 > echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6
10033 > if test -z "$CXXCPP"; then
10034 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then
10035 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10036 > else
10037 >      # Double quotes because CXXCPP needs to be expanded
10038 >    for CXXCPP in "$CXX -E" "/lib/cpp"
10039 >    do
10040 >      ac_preproc_ok=false
10041 > for ac_cxx_preproc_warn_flag in '' yes
10042 > do
10043 >  # Use a header file that comes with gcc, so configuring glibc
10044 >  # with a fresh cross-compiler works.
10045 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10046 >  # <limits.h> exists even on freestanding compilers.
10047 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10048 >  # not just through cpp. "Syntax error" is here to catch this case.
10049 >  cat >conftest.$ac_ext <<_ACEOF
10050 > /* confdefs.h.  */
10051 > _ACEOF
10052 > cat confdefs.h >>conftest.$ac_ext
10053 > cat >>conftest.$ac_ext <<_ACEOF
10054 > /* end confdefs.h.  */
10055 > #ifdef __STDC__
10056 > # include <limits.h>
10057 > #else
10058 > # include <assert.h>
10059 > #endif
10060 >                     Syntax error
10061 > _ACEOF
10062 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10063 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10064 >  ac_status=$?
10065 >  grep -v '^ *+' conftest.er1 >conftest.err
10066 >  rm -f conftest.er1
10067 >  cat conftest.err >&5
10068 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10069 >  (exit $ac_status); } >/dev/null; then
10070 >  if test -s conftest.err; then
10071 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10072 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10073 >  else
10074 >    ac_cpp_err=
10075 >  fi
10076 > else
10077 >  ac_cpp_err=yes
10078 > fi
10079 > if test -z "$ac_cpp_err"; then
10080 >  :
10081 > else
10082 >  echo "$as_me: failed program was:" >&5
10083 > sed 's/^/| /' conftest.$ac_ext >&5
10084 >
10085 >  # Broken: fails on valid input.
10086 > continue
10087 > fi
10088 > rm -f conftest.err conftest.$ac_ext
10089 >
10090 >  # OK, works on sane cases.  Now check whether non-existent headers
10091 >  # can be detected and how.
10092 >  cat >conftest.$ac_ext <<_ACEOF
10093 > /* confdefs.h.  */
10094 > _ACEOF
10095 > cat confdefs.h >>conftest.$ac_ext
10096 > cat >>conftest.$ac_ext <<_ACEOF
10097 > /* end confdefs.h.  */
10098 > #include <ac_nonexistent.h>
10099 > _ACEOF
10100 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10101 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10102 >  ac_status=$?
10103 >  grep -v '^ *+' conftest.er1 >conftest.err
10104 >  rm -f conftest.er1
10105 >  cat conftest.err >&5
10106 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10107 >  (exit $ac_status); } >/dev/null; then
10108 >  if test -s conftest.err; then
10109 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10110 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10111 >  else
10112 >    ac_cpp_err=
10113 >  fi
10114 > else
10115 >  ac_cpp_err=yes
10116 > fi
10117 > if test -z "$ac_cpp_err"; then
10118 >  # Broken: success on invalid input.
10119 > continue
10120 > else
10121 >  echo "$as_me: failed program was:" >&5
10122 > sed 's/^/| /' conftest.$ac_ext >&5
10123 >
10124 >  # Passes both tests.
10125 > ac_preproc_ok=:
10126 > break
10127 > fi
10128 > rm -f conftest.err conftest.$ac_ext
10129 >
10130 > done
10131 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10132 > rm -f conftest.err conftest.$ac_ext
10133 > if $ac_preproc_ok; then
10134 >  break
10135 > fi
10136 >
10137 >    done
10138 >    ac_cv_prog_CXXCPP=$CXXCPP
10139 >
10140 > fi
10141 >  CXXCPP=$ac_cv_prog_CXXCPP
10142 > else
10143 >  ac_cv_prog_CXXCPP=$CXXCPP
10144 > fi
10145 > echo "$as_me:$LINENO: result: $CXXCPP" >&5
10146 > echo "${ECHO_T}$CXXCPP" >&6
10147 > ac_preproc_ok=false
10148 > for ac_cxx_preproc_warn_flag in '' yes
10149 > do
10150 >  # Use a header file that comes with gcc, so configuring glibc
10151 >  # with a fresh cross-compiler works.
10152 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
10153 >  # <limits.h> exists even on freestanding compilers.
10154 >  # On the NeXT, cc -E runs the code through the compiler's parser,
10155 >  # not just through cpp. "Syntax error" is here to catch this case.
10156 >  cat >conftest.$ac_ext <<_ACEOF
10157 > /* confdefs.h.  */
10158 > _ACEOF
10159 > cat confdefs.h >>conftest.$ac_ext
10160 > cat >>conftest.$ac_ext <<_ACEOF
10161 > /* end confdefs.h.  */
10162 > #ifdef __STDC__
10163 > # include <limits.h>
10164 > #else
10165 > # include <assert.h>
10166 > #endif
10167 >                     Syntax error
10168 > _ACEOF
10169 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10170 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10171 >  ac_status=$?
10172 >  grep -v '^ *+' conftest.er1 >conftest.err
10173 >  rm -f conftest.er1
10174 >  cat conftest.err >&5
10175 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10176 >  (exit $ac_status); } >/dev/null; then
10177 >  if test -s conftest.err; then
10178 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10179 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10180 >  else
10181 >    ac_cpp_err=
10182 >  fi
10183 > else
10184 >  ac_cpp_err=yes
10185 > fi
10186 > if test -z "$ac_cpp_err"; then
10187 >  :
10188 > else
10189 >  echo "$as_me: failed program was:" >&5
10190 > sed 's/^/| /' conftest.$ac_ext >&5
10191 >
10192 >  # Broken: fails on valid input.
10193 > continue
10194 > fi
10195 > rm -f conftest.err conftest.$ac_ext
10196 >
10197 >  # OK, works on sane cases.  Now check whether non-existent headers
10198 >  # can be detected and how.
10199 >  cat >conftest.$ac_ext <<_ACEOF
10200 > /* confdefs.h.  */
10201 > _ACEOF
10202 > cat confdefs.h >>conftest.$ac_ext
10203 > cat >>conftest.$ac_ext <<_ACEOF
10204 > /* end confdefs.h.  */
10205 > #include <ac_nonexistent.h>
10206 > _ACEOF
10207 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10208 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10209 >  ac_status=$?
10210 >  grep -v '^ *+' conftest.er1 >conftest.err
10211 >  rm -f conftest.er1
10212 >  cat conftest.err >&5
10213 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10214 >  (exit $ac_status); } >/dev/null; then
10215 >  if test -s conftest.err; then
10216 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10217 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10218 >  else
10219 >    ac_cpp_err=
10220 >  fi
10221 > else
10222 >  ac_cpp_err=yes
10223 > fi
10224 > if test -z "$ac_cpp_err"; then
10225 >  # Broken: success on invalid input.
10226 > continue
10227 > else
10228 >  echo "$as_me: failed program was:" >&5
10229 > sed 's/^/| /' conftest.$ac_ext >&5
10230 >
10231 >  # Passes both tests.
10232 > ac_preproc_ok=:
10233 > break
10234 > fi
10235 > rm -f conftest.err conftest.$ac_ext
10236 >
10237 > done
10238 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
10239 > rm -f conftest.err conftest.$ac_ext
10240 > if $ac_preproc_ok; then
10241 >  :
10242 > else
10243 >  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10244 > See \`config.log' for more details." >&5
10245 > echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
10246 > See \`config.log' for more details." >&2;}
10247 >   { (exit 1); exit 1; }; }
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 >  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
10501 >  echo "$as_me:$LINENO: checking for $ac_header" >&5
10502 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10503 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10504 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10505 > fi
10506 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10507 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10508 > else
10509 >  # Is the header compilable?
10510 > echo "$as_me:$LINENO: checking $ac_header usability" >&5
10511 > echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6
10512 > cat >conftest.$ac_ext <<_ACEOF
10513 > /* confdefs.h.  */
10514 > _ACEOF
10515 > cat confdefs.h >>conftest.$ac_ext
10516 > cat >>conftest.$ac_ext <<_ACEOF
10517 > /* end confdefs.h.  */
10518 > $ac_includes_default
10519 > #include <$ac_header>
10520 > _ACEOF
10521 > rm -f conftest.$ac_objext
10522 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10523 >  (eval $ac_compile) 2>conftest.er1
10524 >  ac_status=$?
10525 >  grep -v '^ *+' conftest.er1 >conftest.err
10526 >  rm -f conftest.er1
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"
10531 >                         || test ! -s conftest.err'
10532 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10533 >  (eval $ac_try) 2>&5
10534 >  ac_status=$?
10535 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10536 >  (exit $ac_status); }; } &&
10537 >         { ac_try='test -s conftest.$ac_objext'
10538 >  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10539 >  (eval $ac_try) 2>&5
10540 >  ac_status=$?
10541 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10542 >  (exit $ac_status); }; }; then
10543 >  ac_header_compiler=yes
10544 > else
10545 >  echo "$as_me: failed program was:" >&5
10546 > sed 's/^/| /' conftest.$ac_ext >&5
10547 >
10548 > ac_header_compiler=no
10549 > fi
10550 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10551 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10552 > echo "${ECHO_T}$ac_header_compiler" >&6
10553 >
10554 > # Is the header present?
10555 > echo "$as_me:$LINENO: checking $ac_header presence" >&5
10556 > echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6
10557 > cat >conftest.$ac_ext <<_ACEOF
10558 > /* confdefs.h.  */
10559 > _ACEOF
10560 > cat confdefs.h >>conftest.$ac_ext
10561 > cat >>conftest.$ac_ext <<_ACEOF
10562 > /* end confdefs.h.  */
10563 > #include <$ac_header>
10564 > _ACEOF
10565 > if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10566 >  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10567 >  ac_status=$?
10568 >  grep -v '^ *+' conftest.er1 >conftest.err
10569 >  rm -f conftest.er1
10570 >  cat conftest.err >&5
10571 >  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10572 >  (exit $ac_status); } >/dev/null; then
10573 >  if test -s conftest.err; then
10574 >    ac_cpp_err=$ac_cxx_preproc_warn_flag
10575 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10576 >  else
10577 >    ac_cpp_err=
10578 >  fi
10579 > else
10580 >  ac_cpp_err=yes
10581 > fi
10582 > if test -z "$ac_cpp_err"; then
10583 >  ac_header_preproc=yes
10584 > else
10585 >  echo "$as_me: failed program was:" >&5
10586 > sed 's/^/| /' conftest.$ac_ext >&5
10587 >
10588 >  ac_header_preproc=no
10589 > fi
10590 > rm -f conftest.err conftest.$ac_ext
10591 > echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10592 > echo "${ECHO_T}$ac_header_preproc" >&6
10593 >
10594 > # So?  What about this header?
10595 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10596 >  yes:no: )
10597 >    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10598 > echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10599 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10600 > echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10601 >    ac_header_preproc=yes
10602 >    ;;
10603 >  no:yes:* )
10604 >    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10605 > echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10606 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10607 > echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10608 >    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10609 > echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10610 >    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10611 > echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10612 >    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10613 > echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10614 >    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10615 > echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10616 >    (
10617 >      cat <<\_ASBOX
10618 > ## ------------------------------ ##
10619 > ## Report this to gezelter@nd.edu ##
10620 > ## ------------------------------ ##
10621 > _ASBOX
10622 >    ) |
10623 >      sed "s/^/$as_me: WARNING:     /" >&2
10624 >    ;;
10625 > esac
10626 > echo "$as_me:$LINENO: checking for $ac_header" >&5
10627 > echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
10628 > if eval "test \"\${$as_ac_Header+set}\" = set"; then
10629 >  echo $ECHO_N "(cached) $ECHO_C" >&6
10630 > else
10631 >  eval "$as_ac_Header=\$ac_header_preproc"
10632 > fi
10633 > echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
10634 > echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
10635 >
10636 > fi
10637 > if test `eval echo '${'$as_ac_Header'}'` = yes; then
10638 >  cat >>confdefs.h <<_ACEOF
10639 > #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10640 > _ACEOF
10641 >
10642 > fi
10643 >
10644 > done
10645 >
10646 >
10647 > fi
10648 >
10649 >
10650 >
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: $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 iomanip usability" >&5
10663 > echo $ECHO_N "checking iomanip usability... $ECHO_C" >&6
10664   cat >conftest.$ac_ext <<_ACEOF
10665   /* confdefs.h.  */
10666   _ACEOF
10667   cat confdefs.h >>conftest.$ac_ext
10668   cat >>conftest.$ac_ext <<_ACEOF
10669   /* end confdefs.h.  */
10670 <
10671 < /* Override any gcc2 internal prototype to avoid an error.  */
6981 < #ifdef __cplusplus
6982 < extern "C"
6983 < #endif
6984 < /* We use char because int might match the return type of a gcc2
6985 <   builtin and then its argument prototype would still apply.  */
6986 < char inflateEnd ();
6987 < int
6988 < main ()
6989 < {
6990 < inflateEnd ();
6991 <  ;
6992 <  return 0;
6993 < }
10670 > $ac_includes_default
10671 > #include <iomanip>
10672   _ACEOF
10673 < rm -f conftest.$ac_objext conftest$ac_exeext
10674 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10675 <  (eval $ac_link) 2>conftest.er1
10673 > rm -f conftest.$ac_objext
10674 > if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10675 >  (eval $ac_compile) 2>conftest.er1
10676    ac_status=$?
10677    grep -v '^ *+' conftest.er1 >conftest.err
10678    rm -f conftest.er1
# Line 7008 | Line 10686 | if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
10686    ac_status=$?
10687    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10688    (exit $ac_status); }; } &&
10689 <         { ac_try='test -s conftest$ac_exeext'
10689 >         { ac_try='test -s conftest.$ac_objext'
10690    { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10691    (eval $ac_try) 2>&5
10692    ac_status=$?
10693    echo "$as_me:$LINENO: \$? = $ac_status" >&5
10694    (exit $ac_status); }; }; then
10695 <  ac_cv_lib_z_inflateEnd=yes
10695 >  ac_header_compiler=yes
10696   else
10697    echo "$as_me: failed program was:" >&5
10698   sed 's/^/| /' conftest.$ac_ext >&5
10699  
10700 < ac_cv_lib_z_inflateEnd=no
10700 > ac_header_compiler=no
10701   fi
10702 < rm -f conftest.err conftest.$ac_objext \
10703 <      conftest$ac_exeext conftest.$ac_ext
10704 < LIBS=$ac_check_lib_save_LIBS
7027 < fi
7028 < echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
7029 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6
7030 < if test $ac_cv_lib_z_inflateEnd = yes; then
7031 <  cat >>confdefs.h <<_ACEOF
7032 < #define HAVE_LIBZ 1
7033 < _ACEOF
10702 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10703 > echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10704 > echo "${ECHO_T}$ac_header_compiler" >&6
10705  
10706 <  LIBS="-lz $LIBS"
10707 <
10706 > # Is the header present?
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 <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
10719 >  ac_status=$?
10720 >  grep -v '^ *+' conftest.er1 >conftest.err
10721 >  rm -f conftest.er1
10722 >  cat conftest.err >&5
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_cxx_preproc_warn_flag
10727 >    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10728 >  else
10729 >    ac_cpp_err=
10730 >  fi
10731 > else
10732 >  ac_cpp_err=yes
10733   fi
10734 + if test -z "$ac_cpp_err"; then
10735 +  ac_header_preproc=yes
10736 + else
10737 +  echo "$as_me: failed program was:" >&5
10738 + sed 's/^/| /' conftest.$ac_ext >&5
10739  
10740 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
7040 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
7041 <                echo "$as_me:$LINENO: result: ok" >&5
7042 < echo "${ECHO_T}ok" >&6
7043 <        else
7044 <                #
7045 <                # If either header or library was not found, revert and bomb
7046 <                #
7047 <                echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
7048 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6
7049 <                LDFLAGS="$ZLIB_OLD_LDFLAGS"
7050 <                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
7051 <                echo "$as_me:$LINENO: result: failed" >&5
7052 < echo "${ECHO_T}failed" >&6
7053 <                { { echo "$as_me:$LINENO: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&5
7054 < echo "$as_me: error: either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib" >&2;}
7055 <   { (exit 1); exit 1; }; }
7056 <        fi
10740 >  ac_header_preproc=no
10741   fi
10742 + rm -f conftest.err conftest.$ac_ext
10743 + echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10744 + echo "${ECHO_T}$ac_header_preproc" >&6
10745  
10746 <
10747 <
10748 <
10749 <
10750 <
10751 <
10752 <
10753 <
10754 <
10755 <
10756 <
10757 <
10758 <
10746 > # So?  What about this header?
10747 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10748 >  yes:no: )
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: 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 > ## ------------------------------ ##
10771 > ## Report this to gezelter@nd.edu ##
10772 > ## ------------------------------ ##
10773 > _ASBOX
10774 >    ) |
10775 >      sed "s/^/$as_me: WARNING:     /" >&2
10776 >    ;;
10777 > esac
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 >  ac_cv_header_iomanip=$ac_header_preproc
10784 > fi
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 $ac_cv_header_iomanip = yes; then
10790  
10791  
10792 + cat >>confdefs.h <<\_ACEOF
10793 + #define HAVE_IOMANIP 1
10794 + _ACEOF
10795  
10796  
10797 + else
10798  
10799  
10800 < for ac_header in stdlib.h string.h sys/param.h unistd.h sys/time.h stdio.h conio.h strstream.h iostream.h fstream.h math.h time.h sys/pstat.h sys/sysmp.h sys/sysinfo.h sys/table.h sys/sysctl.h sys/sytemcfg.h machine/hal_sysinfo.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 7225 | Line 10946 | done
10946  
10947   done
10948  
7228 ac_ext=cc
7229 ac_cpp='$CXXCPP $CPPFLAGS'
7230 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7231 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7232 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10949  
10950 + fi
10951  
10952  
10953  
10954  
10955 <
7239 < for ac_header in ctype.h iostream fstream sstream strstream
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 7385 | Line 11101 | done
11101  
11102   done
11103  
7388 ac_ext=c
7389 ac_cpp='$CPP $CPPFLAGS'
7390 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7391 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7392 ac_compiler_gnu=$ac_cv_c_compiler_gnu
11104  
11105  
11106  
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  
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 <
7401 <
7402 <
7403 <
7404 <
7405 <
7406 < for ac_func in rint snprintf sranddev strcasecmp strncasecmp stricmp strnicmp pstat_getstatic sysmp getsysinfo sysctl table
7407 < do
7408 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
7409 < echo "$as_me:$LINENO: checking for $ac_func" >&5
7410 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
7411 < if eval "test \"\${$as_ac_var+set}\" = set"; then
7412 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7413 < else
7414 <  cat >conftest.$ac_ext <<_ACEOF
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.  */
7420 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
7421   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
7422 #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.
7426 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
7427 <    <limits.h> exists even on freestanding compilers.  */
7428 <
7429 < #ifdef __STDC__
7430 < # 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
7442 /* We use char because int might match the return type of a gcc2
7443   builtin and then its argument prototype would still apply.  */
7444 char $ac_func ();
7445 /* The GNU C library defines this for functions which it implements
7446    to always fail with ENOSYS.  Some functions are actually named
7447    something starting with __ and the normal name is an alias.  */
7448 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
7449 choke me
7450 #else
7451 char (*f) () = $ac_func;
11144   #endif
7453 #ifdef __cplusplus
7454 }
7455 #endif
7456
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"
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  
7492 eval "$as_ac_var=no"
11180   fi
11181 < rm -f conftest.err conftest.$ac_objext \
11182 <      conftest$ac_exeext conftest.$ac_ext
7496 < fi
7497 < echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
7498 < echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
7499 < if test `eval echo '${'$as_ac_var'}'` = yes; then
7500 <  cat >>confdefs.h <<_ACEOF
7501 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
7502 < _ACEOF
7503 <
7504 < fi
7505 < done
7506 <
7507 < # special check for _system_configuration because AIX <4.3.2 do not
7508 < # contain the `physmem' member.
7509 < echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
7510 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6
7511 < 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.  */
11188 < #include <sys/systemcfg.h>
11188 >
11189 > #define __USE_STD_IOSTREAM 1
11190 > #ifdef HAVE_IOSTREAM
11191 > #include <iostream>
11192 > #else
11193 > #include <iostream.h>
11194 > #endif
11195 >
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
11203 > #endif
11204   int
11205   main ()
11206   {
11207 < double x = _system_configuration.physmem;
11207 > std::cout<<"Hello World"<<std::endl;return 0;
11208    ;
11209    return 0;
11210   }
# Line 7532 | Line 11218 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
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"
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
# Line 7545 | Line 11231 | if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11231    ac_status=$?
11232    echo "$as_me:$LINENO: \$? = $ac_status" >&5
11233    (exit $ac_status); }; }; then
11234 <  echo "$as_me:$LINENO: result: yes" >&5
7549 < echo "${ECHO_T}yes" >&6
7550 <
7551 < cat >>confdefs.h <<\_ACEOF
7552 < #define HAVE__SYSTEM_CONFIGURATION 1
7553 < _ACEOF
7554 <
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  
7559 echo "$as_me:$LINENO: result: no" >&5
7560 echo "${ECHO_T}no" >&6
11239   fi
11240   rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11241 < echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
11242 < echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6
11243 < if test "${ac_cv_header_time+set}" = set; then
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 > 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 > cat >>confdefs.h <<\_ACEOF
11255 > #define HAVE_STD_IOSTREAM 1
11256 > _ACEOF
11257 >
11258 >  fi
11259 >  if test "$ac_cv_cxx_need_use_std_iostream" = yes; then
11260 >
11261 > cat >>confdefs.h <<\_ACEOF
11262 > #define __USE_STD_IOSTREAM 1
11263 > _ACEOF
11264 >
11265 >  fi
11266 >
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>
7575 < #include <sys/time.h>
7576 < #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)
7582 < return 0;
11305 > std::list<int> foo;return 0;
11306    ;
11307    return 0;
11308   }
# Line 7593 | 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"
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
# Line 7606 | 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  
7614 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)
7645 <  return 0;
7646 < if (sizeof (clock_t))
7647 <  return 0;
11402 > int fd=0;ofstream s;s.attach(fd);
11403    ;
11404    return 0;
11405   }
# Line 7658 | 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"
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
# Line 7671 | 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  
7679 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  
7692 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. */
7710 < #ifndef __cplusplus
7711 <  /* Ultrix mips cc rejects this.  */
7712 <  typedef int charset[2];
7713 <  const charset x;
7714 <  /* SunOS 4.1.1 cc rejects this.  */
7715 <  char const *const *ccp;
7716 <  char **p;
7717 <  /* NEC SVR4.0.2 mips cc rejects this.  */
7718 <  struct point {int x, y;};
7719 <  static struct point const zero = {0,0};
7720 <  /* AIX XL C 1.02.0.0 rejects this.
7721 <     It does not let you subtract one const X* pointer from another in
7722 <     an arm of an if-expression whose if-part is not a constant
7723 <     expression */
7724 <  const char *g = "string";
7725 <  ccp = &g + (g ? g-g : 0);
7726 <  /* HPUX 7.0 cc rejects these. */
7727 <  ++ccp;
7728 <  p = (char**) ccp;
7729 <  ccp = (char const *const *) p;
7730 <  { /* SCO 3.2v4 cc rejects this.  */
7731 <    char *t;
7732 <    char const *s = 0 ? (char *) 0 : (char const *) 0;
7733 <
7734 <    *t++ = 0;
7735 <  }
7736 <  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
7737 <    int x[] = {25, 17};
7738 <    const int *foo = &x[0];
7739 <    ++foo;
7740 <  }
7741 <  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
7742 <    typedef const int *iptr;
7743 <    iptr p = 0;
7744 <    ++p;
7745 <  }
7746 <  { /* AIX XL C 1.02.0.0 rejects this saying
7747 <       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
7748 <    struct s { int j; const int *ap[3]; };
7749 <    struct s *b; b->j = 5;
7750 <  }
7751 <  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
7752 <    const int foo = 10;
7753 <  }
7754 < #endif
7755 <
11500 > ofstream s;s.open("conftest.txt",ios::out|ios::trunc);
11501    ;
11502    return 0;
11503   }
# Line 7766 | 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"
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
# Line 7779 | 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  
7787 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
7792 < echo "${ECHO_T}$ac_cv_c_const" >&6
7793 < if test $ac_cv_c_const = no; then
7794 <
7795 < cat >>confdefs.h <<\_ACEOF
7796 < #define const
7797 < _ACEOF
7798 <
7799 < fi
7800 <
7801 < echo "$as_me:$LINENO: checking for inline" >&5
7802 < echo $ECHO_N "checking for inline... $ECHO_C" >&6
7803 < if test "${ac_cv_c_inline+set}" = set; then
7804 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7805 < else
7806 <  ac_cv_c_inline=no
7807 < for ac_kw in inline __inline__ __inline; do
7808 <  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 7827 | 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"
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
# Line 7840 | 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 + cat >>confdefs.h <<\_ACEOF
11609 + #define HAVE_FSTREAM_OPEN 1
11610 + _ACEOF
11611  
11612 < case $ac_cv_c_inline in
11613 <  inline | yes) ;;
11614 <  *)
11615 <    case $ac_cv_c_inline in
11616 <      no) ac_val=;;
7862 <      *) ac_val=$ac_cv_c_inline;;
7863 <    esac
7864 <    cat >>confdefs.h <<_ACEOF
7865 < #ifndef __cplusplus
7866 < #define inline $ac_val
7867 < #endif
11612 >  fi
11613 >  if test "$ac_cv_cxx_fstream_open_prot" = yes; then
11614 >
11615 > cat >>confdefs.h <<\_ACEOF
11616 > #define FSTREAM_OPEN_PROT 1
11617   _ACEOF
7869    ;;
7870 esac
11618  
11619 +  fi
11620  
11621  
7874  # clean out junk possibly left behind by a previous configuration
7875  rm -f src/getopt.h
7876  # Check for getopt_long support
11622  
11623 < for ac_header in getopt.h
11623 >
11624 >
11625 >
11626 >
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 7908 | 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"
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
# Line 7952 | 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 7973 | 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 8024 | 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
8032 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6
8033 < 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 8039 | Line 11792 | cat >>conftest.$ac_ext <<_ACEOF
11792   cat confdefs.h >>conftest.$ac_ext
11793   cat >>conftest.$ac_ext <<_ACEOF
11794   /* end confdefs.h.  */
8042 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
8043   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
8044 #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__
8052 < # include <limits.h>
8053 < #else
8054 < # 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
8056
8057 #undef $ac_func
8058
8059 /* Override any gcc2 internal prototype to avoid an error.  */
8060 #ifdef __cplusplus
8061 extern "C"
8062 {
11803   #endif
8064 /* We use char because int might match the return type of a gcc2
8065   builtin and then its argument prototype would still apply.  */
8066 char $ac_func ();
8067 /* The GNU C library defines this for functions which it implements
8068    to always fail with ENOSYS.  Some functions are actually named
8069    something starting with __ and the normal name is an alias.  */
8070 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)
8071 choke me
8072 #else
8073 char (*f) () = $ac_func;
8074 #endif
8075 #ifdef __cplusplus
8076 }
8077 #endif
8078
11804   int
11805   main ()
11806   {
11807 < return f != $ac_func;
11807 > const char *foo = __func__;
11808    ;
11809    return 0;
11810   }
11811   _ACEOF
11812 < rm -f conftest.$ac_objext conftest$ac_exeext
11813 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11814 <  (eval $ac_link) 2>conftest.er1
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_c_werror_flag"
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_exeext'
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 <  eval "$as_ac_var=yes"
11834 >  ac_cv_cpp_func=yes
11835   else
11836    echo "$as_me: failed program was:" >&5
11837   sed 's/^/| /' conftest.$ac_ext >&5
11838  
8114 eval "$as_ac_var=no"
8115 fi
8116 rm -f conftest.err conftest.$ac_objext \
8117      conftest$ac_exeext conftest.$ac_ext
8118 fi
8119 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5
8120 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6
8121 if test `eval echo '${'$as_ac_var'}'` = yes; then
8122  cat >>confdefs.h <<_ACEOF
8123 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
8124 _ACEOF
8125
8126 else
8127  # FreeBSD has a gnugetopt library for this
8128    echo "$as_me:$LINENO: checking for getopt_long in -lgnugetopt" >&5
8129 echo $ECHO_N "checking for getopt_long in -lgnugetopt... $ECHO_C" >&6
8130 if test "${ac_cv_lib_gnugetopt_getopt_long+set}" = set; then
8131  echo $ECHO_N "(cached) $ECHO_C" >&6
8132 else
8133  ac_check_lib_save_LIBS=$LIBS
8134 LIBS="-lgnugetopt  $LIBS"
11839   cat >conftest.$ac_ext <<_ACEOF
11840   /* confdefs.h.  */
11841   _ACEOF
# Line 8139 | Line 11843 | cat >>conftest.$ac_ext <<_ACEOF
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"
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
11853 < /* We use char because int might match the return type of a gcc2
8147 <   builtin and then its argument prototype would still apply.  */
8148 < char getopt_long ();
11853 > #endif
11854   int
11855   main ()
11856   {
11857 < getopt_long ();
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"
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 <  ac_cv_lib_gnugetopt_getopt_long=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 < ac_cv_lib_gnugetopt_getopt_long=no
11889 > ac_cv_cpp_func=no
11890   fi
11891 < rm -f conftest.err conftest.$ac_objext \
8187 <      conftest$ac_exeext conftest.$ac_ext
8188 < LIBS=$ac_check_lib_save_LIBS
11891 > rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11892   fi
11893 < echo "$as_me:$LINENO: result: $ac_cv_lib_gnugetopt_getopt_long" >&5
11894 < echo "${ECHO_T}$ac_cv_lib_gnugetopt_getopt_long" >&6
11895 < if test $ac_cv_lib_gnugetopt_getopt_long = yes; then
11896 <  cat >>confdefs.h <<\_ACEOF
11897 < #define HAVE_GETOPT_LONG 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 < else
8198 <  # use the GNU replacement
8199 <      case $LIBOBJS in
8200 <    "getopt.$ac_objext"   | \
8201 <  *" getopt.$ac_objext"   | \
8202 <    "getopt.$ac_objext "* | \
8203 <  *" getopt.$ac_objext "* ) ;;
8204 <  *) LIBOBJS="$LIBOBJS getopt.$ac_objext" ;;
8205 < esac
11903 > elif test $ac_cv_cpp_func = no; then
11904  
11905 <      case $LIBOBJS in
11906 <    "getopt1.$ac_objext"   | \
11907 <  *" getopt1.$ac_objext"   | \
8210 <    "getopt1.$ac_objext "* | \
8211 <  *" getopt1.$ac_objext "* ) ;;
8212 <  *) LIBOBJS="$LIBOBJS getopt1.$ac_objext" ;;
8213 < esac
11905 > cat >>confdefs.h <<\_ACEOF
11906 > #define __func__ ""
11907 > _ACEOF
11908  
8215                ac_config_links="$ac_config_links src/getopt.h:src/utils/gnugetopt.h"
8216
11909   fi
11910  
8219 fi
8220 done
11911  
11912  
11913  
11914 +
11915   case $debug in
11916    1)
11917       ;;
# Line 8229 | Line 11920 | case $debug in
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 +        :
12015 +
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 +
12025 + fi
12026 +
12027 +
12028 + fi
12029 +
12030 +
12031 +
12032 +
12033 +
12034 +
12035 +
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 8309 | 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 8322 | 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 8349 | 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 8380 | 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 8403 | 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 8432 | 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 8455 | 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 8488 | 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 8546 | 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 8579 | 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 8607 | 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 8652 | 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 8763 | 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 8776 | 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 8803 | 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 8834 | 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 8857 | 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 8886 | 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 8909 | 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 8942 | 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 9000 | 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 9031 | Line 12839 | fi
12839  
12840                  fi
12841                  if test -z "$CPU_FLAGS"; then
9034
9035
9036 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mcpu=powerpc" >&5
9037 echo $ECHO_N "checking whether ${CXX-c++} accepts -mcpu=powerpc... $ECHO_C" >&6
9038 if test "${ac_m_cpu_powerpc+set}" = set; then
9039  echo $ECHO_N "(cached) $ECHO_C" >&6
9040 else
9041  echo 'void f(){}' > conftest.cpp
9042 if test -z "`${CXX-c++} -mcpu=powerpc -c conftest.cpp 2>&1`"; then
9043        ac_m_cpu_powerpc=yes
9044 else
9045        ac_m_cpu_powerpc=no
9046 fi
9047 rm -f conftest*
9048
9049 fi
9050 echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
9051 echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
9052 if test "$ac_m_cpu_powerpc" = yes; then
9053        :
9054        CPU_FLAGS=-mcpu=powerpc
9055 else
9056        :
9057
9058 fi
9059
9060                fi
9061                if test -z "$CPU_FLAGS"; then
9062
9063
9064 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts -mpowerpc" >&5
9065 echo $ECHO_N "checking whether ${CXX-c++} accepts -mpowerpc... $ECHO_C" >&6
9066 if test "${ac_m_powerpc+set}" = set; then
9067  echo $ECHO_N "(cached) $ECHO_C" >&6
9068 else
9069  echo 'void f(){}' > conftest.cpp
9070 if test -z "`${CXX-c++} -mpowerpc -c conftest.cpp 2>&1`"; then
9071        ac_m_powerpc=yes
9072 else
9073        ac_m_powerpc=no
9074 fi
9075 rm -f conftest*
9076
9077 fi
9078 echo "$as_me:$LINENO: result: $ac_m_powerpc" >&5
9079 echo "${ECHO_T}$ac_m_powerpc" >&6
9080 if test "$ac_m_powerpc" = yes; then
9081        :
9082        CPU_FLAGS=-mpowerpc
9083 else
9084        :
9085
9086 fi
9087
9088                fi
9089          esac
9090  fi
9091
9092  if test -n "$CPU_FLAGS"; then
9093        CXXFLAGS="$CXXFLAGS $CPU_FLAGS"
9094  fi
9095
9096  if test -z "$CXXFLAGS"; then
9097        echo ""
9098        echo "**********************************************************"
9099        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
9100        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
9101        echo "* (otherwise, a default of CXXFLAGS=-O3 will be used)    *"
9102        echo "**********************************************************"
9103        echo ""
9104        CXXFLAGS="-O3"
9105  fi
9106
9107
9108
9109 echo "$as_me:$LINENO: checking whether ${CXX-c++} accepts ${CXXFLAGS}" >&5
9110 echo $ECHO_N "checking whether ${CXX-c++} accepts ${CXXFLAGS}... $ECHO_C" >&6
9111 if test "${ac_guessed_cxxflags+set}" = set; then
9112  echo $ECHO_N "(cached) $ECHO_C" >&6
9113 else
9114  echo 'void f(){}' > conftest.cpp
9115 if test -z "`${CXX-c++} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
9116        ac_guessed_cxxflags=yes
9117 else
9118        ac_guessed_cxxflags=no
9119 fi
9120 rm -f conftest*
9121
9122 fi
9123 echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
9124 echo "${ECHO_T}$ac_guessed_cxxflags" >&6
9125 if test "$ac_guessed_cxxflags" = yes; then
9126        :
9127
9128 else
9129        :
9130
9131        echo ""
9132        echo "**********************************************************"
9133        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
9134        echo "* your compiler.                                         *"
9135        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
9136        echo "**********************************************************"
9137        echo ""
9138        CXXFLAGS=""
9139
9140 fi
9141
9142
9143 fi
9144
9145
9146
9147
9148
9149 # Try to determine "good" native compiler flags if none specified on command
9150 # line
9151
9152 if test x"$F90FLAGS" = x ; then
9153  F90FLAGS=""
9154  case "${host_cpu}-${host_os}" in
9155
9156  *linux*) if test "$F90" = ifc -o "$F90" = ifort; then
9157                    F90FLAGS="-O"
9158                fi;;
9159   rs6000*-aix*)  if test "$F90" = xlf90 -o "$F90" = f90; then
9160                    F90FLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
9161                fi;;
9162   powerpc*-aix*)
9163        if test "$F90" = f90 -o "$F90" = xlf90; then
9164                F90FLAGS="-O3 -qarch=ppc -qansialias -w"
9165                echo "*******************************************************"
9166                echo "*  You have AIX on an unknown powerpc system.  It is  *"
9167                echo "*  recommended that you use                           *"
9168                echo "*                                                     *"
9169                echo "*  F90FLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
9170                echo "*                                 ^^^                 *"
9171                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
9172                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
9173                echo "*******************************************************"
9174        fi;;
9175   *darwin*)
9176        if test "$F90" = f90 -o "$F90" = xlf90 -o "$F90" = xlf95; then
9177                F90FLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
9178        fi;;
9179  esac
9180
9181  if test -n "$CPU_FLAGS"; then
9182        F90FLAGS="$F90FLAGS $CPU_FLAGS"
9183  fi
9184
9185  if test -z "$F90FLAGS"; then
9186        echo ""
9187        echo "**********************************************************"
9188        echo "* WARNING: Don't know the best F90FLAGS for this system  *"
9189        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
9190        echo "* (otherwise, a default of F90FLAGS=-O3 will be used)    *"
9191        echo "**********************************************************"
9192        echo ""
9193        F90FLAGS="-O3"
9194  fi
9195
9196
9197 echo "$as_me:$LINENO: checking whether ${F90-f90} accepts ${F90FLAGS}" >&5
9198 echo $ECHO_N "checking whether ${F90-f90} accepts ${F90FLAGS}... $ECHO_C" >&6
9199 if test "${ac_guessed_f90flags+set}" = set; then
9200  echo $ECHO_N "(cached) $ECHO_C" >&6
9201 else
9202
9203
9204
9205 ac_ext=f90
9206 ac_compile='$F90 -c $F90FLAGS conftest.$ac_ext >&5'
9207 ac_link='$F90 -o conftest$ac_exeext $F90FLAGS $LD90FLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9208 ac_compiler_gnu=$ac_cv_f90_compiler_gnu
12842  
9210 echo 'program main' > conftest.$ac_ext
9211 echo 'end program main' >> conftest.$ac_ext
9212 ac_compile='${F90-f90} -c ${F90FLAGS} $F90FLAGS conftest.$ac_ext 1>&5'
9213 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9214  (eval $ac_compile) 2>&5
9215  ac_status=$?
9216  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9217  (exit $ac_status); }; then
9218        ac_guessed_f90flags=yes
9219 else
9220        ac_guessed_f90flags=no
9221 fi
9222 rm -f conftest*
9223 ac_ext=c
9224 ac_cpp='$CPP $CPPFLAGS'
9225 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9226 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9227 ac_compiler_gnu=$ac_cv_c_compiler_gnu
12843  
12844 <
12845 < fi
12846 < echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
9232 < echo "${ECHO_T}$ac_guessed_f90flags" >&6
9233 < if test "$ac_guessed_f90flags" = yes; then
9234 <        :
9235 <
9236 < else
9237 <        :
9238 <
9239 <        echo ""
9240 <        echo "**********************************************************"
9241 <        echo "* WARNING: The guessed F90FLAGS don't seem to work with  *"
9242 <        echo "* your compiler.                                         *"
9243 <        echo "* Use  make F90FLAGS=..., or edit the top level Makefile *"
9244 <        echo "**********************************************************"
9245 <        echo ""
9246 <        F90FLAGS=""
9247 <
9248 < fi
9249 <
9250 <
9251 < fi
9252 <
9253 <     ;;
9254 < esac
9255 <
9256 < ac_ext=cc
9257 < ac_cpp='$CXXCPP $CPPFLAGS'
9258 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9259 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9260 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9261 <
9262 < # AC_CPP_FUNC
9263 < # ------------------ #
9264 < # Checks to see if ANSI C99 CPP variable __func__ works.
9265 < # If not, perhaps __FUNCTION__ works instead.
9266 < # If not, we'll just define __func__ to "".
9267 < # AC_CPP_FUNC
9268 <
9269 <
9270 < echo "$as_me:$LINENO: checking for an ANSI C99-conforming __func__" >&5
9271 < echo $ECHO_N "checking for an ANSI C99-conforming __func__... $ECHO_C" >&6
9272 < if test "${ac_cv_cpp_func+set}" = set; then
9273 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9274 < else
9275 <  cat >conftest.$ac_ext <<_ACEOF
9276 < /* confdefs.h.  */
9277 < _ACEOF
9278 < cat confdefs.h >>conftest.$ac_ext
9279 < cat >>conftest.$ac_ext <<_ACEOF
9280 < /* end confdefs.h.  */
9281 <
9282 < int
9283 < main ()
9284 < {
9285 < const char *foo = __func__;
9286 <  ;
9287 <  return 0;
9288 < }
9289 < _ACEOF
9290 < rm -f conftest.$ac_objext
9291 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9292 <  (eval $ac_compile) 2>conftest.er1
9293 <  ac_status=$?
9294 <  grep -v '^ *+' conftest.er1 >conftest.err
9295 <  rm -f conftest.er1
9296 <  cat conftest.err >&5
9297 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9298 <  (exit $ac_status); } &&
9299 <         { ac_try='test -z "$ac_cxx_werror_flag"
9300 <                         || test ! -s conftest.err'
9301 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9302 <  (eval $ac_try) 2>&5
9303 <  ac_status=$?
9304 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9305 <  (exit $ac_status); }; } &&
9306 <         { ac_try='test -s conftest.$ac_objext'
9307 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9308 <  (eval $ac_try) 2>&5
9309 <  ac_status=$?
9310 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9311 <  (exit $ac_status); }; }; then
9312 <  ac_cv_cpp_func=yes
9313 < else
9314 <  echo "$as_me: failed program was:" >&5
9315 < sed 's/^/| /' conftest.$ac_ext >&5
9316 <
9317 < cat >conftest.$ac_ext <<_ACEOF
9318 < /* confdefs.h.  */
9319 < _ACEOF
9320 < cat confdefs.h >>conftest.$ac_ext
9321 < cat >>conftest.$ac_ext <<_ACEOF
9322 < /* end confdefs.h.  */
9323 <
9324 < int
9325 < main ()
9326 < {
9327 < const char *foo = __FUNCTION__;
9328 <  ;
9329 <  return 0;
9330 < }
9331 < _ACEOF
9332 < rm -f conftest.$ac_objext
9333 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
9334 <  (eval $ac_compile) 2>conftest.er1
9335 <  ac_status=$?
9336 <  grep -v '^ *+' conftest.er1 >conftest.err
9337 <  rm -f conftest.er1
9338 <  cat conftest.err >&5
9339 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9340 <  (exit $ac_status); } &&
9341 <         { ac_try='test -z "$ac_cxx_werror_flag"
9342 <                         || test ! -s conftest.err'
9343 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9344 <  (eval $ac_try) 2>&5
9345 <  ac_status=$?
9346 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9347 <  (exit $ac_status); }; } &&
9348 <         { ac_try='test -s conftest.$ac_objext'
9349 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9350 <  (eval $ac_try) 2>&5
9351 <  ac_status=$?
9352 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9353 <  (exit $ac_status); }; }; then
9354 <  ac_cv_cpp_func=__FUNCTION__
9355 < else
9356 <  echo "$as_me: failed program was:" >&5
9357 < sed 's/^/| /' conftest.$ac_ext >&5
9358 <
9359 < ac_cv_cpp_func=no
9360 < fi
9361 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9362 < fi
9363 < rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
9364 < fi
9365 < echo "$as_me:$LINENO: result: $ac_cv_cpp_func" >&5
9366 < echo "${ECHO_T}$ac_cv_cpp_func" >&6
9367 < if test $ac_cv_cpp_func = __FUNCTION__; then
9368 <
9369 < cat >>confdefs.h <<\_ACEOF
9370 < #define __func__ __FUNCTION__
9371 < _ACEOF
9372 <
9373 < elif test $ac_cv_cpp_func = no; then
9374 <
9375 < cat >>confdefs.h <<\_ACEOF
9376 < #define __func__ ""
9377 < _ACEOF
9378 <
9379 < fi
9380 <
9381 <
9382 < ac_ext=c
9383 < ac_cpp='$CPP $CPPFLAGS'
9384 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9385 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9386 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
9387 <
9388 <
9389 < # Find a good install program.  We prefer a C program (faster),
9390 < # so one script is as good as another.  But avoid the broken or
9391 < # incompatible versions:
9392 < # SysV /etc/install, /usr/sbin/install
9393 < # SunOS /usr/etc/install
9394 < # IRIX /sbin/install
9395 < # AIX /bin/install
9396 < # AmigaOS /C/install, which installs bootblocks on floppy discs
9397 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
9398 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
9399 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
9400 < # OS/2's system install, which has a completely different semantic
9401 < # ./install, which can be erroneously created by make from ./install.sh.
9402 < echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
9403 < echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
9404 < if test -z "$INSTALL"; then
9405 < if test "${ac_cv_path_install+set}" = set; then
9406 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9407 < else
9408 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9409 < for as_dir in $PATH
9410 < do
9411 <  IFS=$as_save_IFS
9412 <  test -z "$as_dir" && as_dir=.
9413 <  # Account for people who put trailing slashes in PATH elements.
9414 < case $as_dir/ in
9415 <  ./ | .// | /cC/* | \
9416 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
9417 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
9418 <  /usr/ucb/* ) ;;
9419 <  *)
9420 <    # OSF1 and SCO ODT 3.0 have their own names for install.
9421 <    # Don't use installbsd from OSF since it installs stuff as root
9422 <    # by default.
9423 <    for ac_prog in ginstall scoinst install; do
9424 <      for ac_exec_ext in '' $ac_executable_extensions; do
9425 <        if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
9426 <          if test $ac_prog = install &&
9427 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
9428 <            # AIX install.  It has an incompatible calling convention.
9429 <            :
9430 <          elif test $ac_prog = install &&
9431 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
9432 <            # program-specific install script used by HP pwplus--don't use.
9433 <            :
9434 <          else
9435 <            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
9436 <            break 3
9437 <          fi
9438 <        fi
9439 <      done
9440 <    done
9441 <    ;;
9442 < esac
9443 < done
9444 <
9445 <
9446 < fi
9447 <  if test "${ac_cv_path_install+set}" = set; then
9448 <    INSTALL=$ac_cv_path_install
9449 <  else
9450 <    # As a last resort, use the slow shell script.  We don't cache a
9451 <    # path for INSTALL within a source directory, because that will
9452 <    # break other packages using the cache if that directory is
9453 <    # removed, or if the path is relative.
9454 <    INSTALL=$ac_install_sh
9455 <  fi
9456 < fi
9457 < echo "$as_me:$LINENO: result: $INSTALL" >&5
9458 < echo "${ECHO_T}$INSTALL" >&6
9459 <
9460 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
9461 < # It thinks the first close brace ends the variable substitution.
9462 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
9463 <
9464 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
9465 <
9466 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
9467 <
9468 < echo "$as_me:$LINENO: checking whether ln -s works" >&5
9469 < echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
9470 < LN_S=$as_ln_s
9471 < if test "$LN_S" = "ln -s"; then
9472 <  echo "$as_me:$LINENO: result: yes" >&5
9473 < echo "${ECHO_T}yes" >&6
9474 < else
9475 <  echo "$as_me:$LINENO: result: no, using $LN_S" >&5
9476 < echo "${ECHO_T}no, using $LN_S" >&6
9477 < fi
9478 <
9479 < echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
9480 < echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6
9481 < set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`
9482 < if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then
9483 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9484 < else
9485 <  cat >conftest.make <<\_ACEOF
9486 < all:
9487 <        @echo 'ac_maketemp="$(MAKE)"'
9488 < _ACEOF
9489 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
9490 < eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`
9491 < if test -n "$ac_maketemp"; then
9492 <  eval ac_cv_prog_make_${ac_make}_set=yes
9493 < else
9494 <  eval ac_cv_prog_make_${ac_make}_set=no
9495 < fi
9496 < rm -f conftest.make
9497 < fi
9498 < if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then
9499 <  echo "$as_me:$LINENO: result: yes" >&5
9500 < echo "${ECHO_T}yes" >&6
9501 <  SET_MAKE=
9502 < else
9503 <  echo "$as_me:$LINENO: result: no" >&5
9504 < echo "${ECHO_T}no" >&6
9505 <  SET_MAKE="MAKE=${MAKE-make}"
9506 < fi
9507 <
9508 < if test -n "$ac_tool_prefix"; then
9509 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
9510 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
9511 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9512 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9513 < if test "${ac_cv_prog_RANLIB+set}" = set; then
9514 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9515 < else
9516 <  if test -n "$RANLIB"; then
9517 <  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
9518 < else
9519 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9520 < for as_dir in $PATH
9521 < do
9522 <  IFS=$as_save_IFS
9523 <  test -z "$as_dir" && as_dir=.
9524 <  for ac_exec_ext in '' $ac_executable_extensions; do
9525 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9526 <    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
9527 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9528 <    break 2
9529 <  fi
9530 < done
9531 < done
9532 <
9533 < fi
9534 < fi
9535 < RANLIB=$ac_cv_prog_RANLIB
9536 < if test -n "$RANLIB"; then
9537 <  echo "$as_me:$LINENO: result: $RANLIB" >&5
9538 < echo "${ECHO_T}$RANLIB" >&6
9539 < else
9540 <  echo "$as_me:$LINENO: result: no" >&5
9541 < echo "${ECHO_T}no" >&6
9542 < fi
9543 <
9544 < fi
9545 < if test -z "$ac_cv_prog_RANLIB"; then
9546 <  ac_ct_RANLIB=$RANLIB
9547 <  # Extract the first word of "ranlib", so it can be a program name with args.
9548 < set dummy ranlib; ac_word=$2
9549 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9550 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9551 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
9552 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9553 < else
9554 <  if test -n "$ac_ct_RANLIB"; then
9555 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
9556 < else
9557 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9558 < for as_dir in $PATH
9559 < do
9560 <  IFS=$as_save_IFS
9561 <  test -z "$as_dir" && as_dir=.
9562 <  for ac_exec_ext in '' $ac_executable_extensions; do
9563 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9564 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
9565 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9566 <    break 2
9567 <  fi
9568 < done
9569 < done
9570 <
9571 <  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
9572 < fi
9573 < fi
9574 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
9575 < if test -n "$ac_ct_RANLIB"; then
9576 <  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
9577 < echo "${ECHO_T}$ac_ct_RANLIB" >&6
9578 < else
9579 <  echo "$as_me:$LINENO: result: no" >&5
9580 < echo "${ECHO_T}no" >&6
9581 < fi
9582 <
9583 <  RANLIB=$ac_ct_RANLIB
9584 < else
9585 <  RANLIB="$ac_cv_prog_RANLIB"
9586 < fi
9587 <
9588 < for ac_prog in 'bison -y' byacc
9589 < do
9590 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
9591 < set dummy $ac_prog; ac_word=$2
9592 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9593 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9594 < if test "${ac_cv_prog_YACC+set}" = set; then
9595 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9596 < else
9597 <  if test -n "$YACC"; then
9598 <  ac_cv_prog_YACC="$YACC" # Let the user override the test.
9599 < else
9600 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9601 < for as_dir in $PATH
9602 < do
9603 <  IFS=$as_save_IFS
9604 <  test -z "$as_dir" && as_dir=.
9605 <  for ac_exec_ext in '' $ac_executable_extensions; do
9606 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9607 <    ac_cv_prog_YACC="$ac_prog"
9608 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9609 <    break 2
9610 <  fi
9611 < done
9612 < done
9613 <
9614 < fi
9615 < fi
9616 < YACC=$ac_cv_prog_YACC
9617 < if test -n "$YACC"; then
9618 <  echo "$as_me:$LINENO: result: $YACC" >&5
9619 < echo "${ECHO_T}$YACC" >&6
9620 < else
9621 <  echo "$as_me:$LINENO: result: no" >&5
9622 < echo "${ECHO_T}no" >&6
9623 < fi
9624 <
9625 <  test -n "$YACC" && break
9626 < done
9627 < test -n "$YACC" || YACC="yacc"
9628 <
9629 < for ac_prog in flex lex
9630 < do
9631 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
9632 < set dummy $ac_prog; ac_word=$2
9633 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9634 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9635 < if test "${ac_cv_prog_LEX+set}" = set; then
9636 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9637 < else
9638 <  if test -n "$LEX"; then
9639 <  ac_cv_prog_LEX="$LEX" # Let the user override the test.
9640 < else
9641 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9642 < for as_dir in $PATH
9643 < do
9644 <  IFS=$as_save_IFS
9645 <  test -z "$as_dir" && as_dir=.
9646 <  for ac_exec_ext in '' $ac_executable_extensions; do
9647 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9648 <    ac_cv_prog_LEX="$ac_prog"
9649 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9650 <    break 2
9651 <  fi
9652 < done
9653 < done
9654 <
9655 < fi
9656 < fi
9657 < LEX=$ac_cv_prog_LEX
9658 < if test -n "$LEX"; then
9659 <  echo "$as_me:$LINENO: result: $LEX" >&5
9660 < echo "${ECHO_T}$LEX" >&6
9661 < else
9662 <  echo "$as_me:$LINENO: result: no" >&5
9663 < echo "${ECHO_T}no" >&6
9664 < fi
9665 <
9666 <  test -n "$LEX" && break
9667 < done
9668 < test -n "$LEX" || LEX=":"
9669 <
9670 < if test -z "$LEXLIB"
9671 < then
9672 <  echo "$as_me:$LINENO: checking for yywrap in -lfl" >&5
9673 < echo $ECHO_N "checking for yywrap in -lfl... $ECHO_C" >&6
9674 < if test "${ac_cv_lib_fl_yywrap+set}" = set; then
9675 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9676 < else
9677 <  ac_check_lib_save_LIBS=$LIBS
9678 < LIBS="-lfl  $LIBS"
9679 < cat >conftest.$ac_ext <<_ACEOF
9680 < /* confdefs.h.  */
9681 < _ACEOF
9682 < cat confdefs.h >>conftest.$ac_ext
9683 < cat >>conftest.$ac_ext <<_ACEOF
9684 < /* end confdefs.h.  */
9685 <
9686 < /* Override any gcc2 internal prototype to avoid an error.  */
9687 < #ifdef __cplusplus
9688 < extern "C"
9689 < #endif
9690 < /* We use char because int might match the return type of a gcc2
9691 <   builtin and then its argument prototype would still apply.  */
9692 < char yywrap ();
9693 < int
9694 < main ()
9695 < {
9696 < yywrap ();
9697 <  ;
9698 <  return 0;
9699 < }
9700 < _ACEOF
9701 < rm -f conftest.$ac_objext conftest$ac_exeext
9702 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9703 <  (eval $ac_link) 2>conftest.er1
9704 <  ac_status=$?
9705 <  grep -v '^ *+' conftest.er1 >conftest.err
9706 <  rm -f conftest.er1
9707 <  cat conftest.err >&5
9708 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9709 <  (exit $ac_status); } &&
9710 <         { ac_try='test -z "$ac_c_werror_flag"
9711 <                         || test ! -s conftest.err'
9712 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9713 <  (eval $ac_try) 2>&5
9714 <  ac_status=$?
9715 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9716 <  (exit $ac_status); }; } &&
9717 <         { ac_try='test -s conftest$ac_exeext'
9718 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9719 <  (eval $ac_try) 2>&5
9720 <  ac_status=$?
9721 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9722 <  (exit $ac_status); }; }; then
9723 <  ac_cv_lib_fl_yywrap=yes
9724 < else
9725 <  echo "$as_me: failed program was:" >&5
9726 < sed 's/^/| /' conftest.$ac_ext >&5
9727 <
9728 < ac_cv_lib_fl_yywrap=no
9729 < fi
9730 < rm -f conftest.err conftest.$ac_objext \
9731 <      conftest$ac_exeext conftest.$ac_ext
9732 < LIBS=$ac_check_lib_save_LIBS
9733 < fi
9734 < echo "$as_me:$LINENO: result: $ac_cv_lib_fl_yywrap" >&5
9735 < echo "${ECHO_T}$ac_cv_lib_fl_yywrap" >&6
9736 < if test $ac_cv_lib_fl_yywrap = yes; then
9737 <  LEXLIB="-lfl"
9738 < else
9739 <  echo "$as_me:$LINENO: checking for yywrap in -ll" >&5
9740 < echo $ECHO_N "checking for yywrap in -ll... $ECHO_C" >&6
9741 < if test "${ac_cv_lib_l_yywrap+set}" = set; then
9742 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9743 < else
9744 <  ac_check_lib_save_LIBS=$LIBS
9745 < LIBS="-ll  $LIBS"
9746 < cat >conftest.$ac_ext <<_ACEOF
9747 < /* confdefs.h.  */
9748 < _ACEOF
9749 < cat confdefs.h >>conftest.$ac_ext
9750 < cat >>conftest.$ac_ext <<_ACEOF
9751 < /* end confdefs.h.  */
9752 <
9753 < /* Override any gcc2 internal prototype to avoid an error.  */
9754 < #ifdef __cplusplus
9755 < extern "C"
9756 < #endif
9757 < /* We use char because int might match the return type of a gcc2
9758 <   builtin and then its argument prototype would still apply.  */
9759 < char yywrap ();
9760 < int
9761 < main ()
9762 < {
9763 < yywrap ();
9764 <  ;
9765 <  return 0;
9766 < }
9767 < _ACEOF
9768 < rm -f conftest.$ac_objext conftest$ac_exeext
9769 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9770 <  (eval $ac_link) 2>conftest.er1
9771 <  ac_status=$?
9772 <  grep -v '^ *+' conftest.er1 >conftest.err
9773 <  rm -f conftest.er1
9774 <  cat conftest.err >&5
9775 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9776 <  (exit $ac_status); } &&
9777 <         { ac_try='test -z "$ac_c_werror_flag"
9778 <                         || test ! -s conftest.err'
9779 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9780 <  (eval $ac_try) 2>&5
9781 <  ac_status=$?
9782 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9783 <  (exit $ac_status); }; } &&
9784 <         { ac_try='test -s conftest$ac_exeext'
9785 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9786 <  (eval $ac_try) 2>&5
9787 <  ac_status=$?
9788 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9789 <  (exit $ac_status); }; }; then
9790 <  ac_cv_lib_l_yywrap=yes
9791 < else
9792 <  echo "$as_me: failed program was:" >&5
9793 < sed 's/^/| /' conftest.$ac_ext >&5
9794 <
9795 < ac_cv_lib_l_yywrap=no
9796 < fi
9797 < rm -f conftest.err conftest.$ac_objext \
9798 <      conftest$ac_exeext conftest.$ac_ext
9799 < LIBS=$ac_check_lib_save_LIBS
9800 < fi
9801 < echo "$as_me:$LINENO: result: $ac_cv_lib_l_yywrap" >&5
9802 < echo "${ECHO_T}$ac_cv_lib_l_yywrap" >&6
9803 < if test $ac_cv_lib_l_yywrap = yes; then
9804 <  LEXLIB="-ll"
9805 < fi
9806 <
9807 < fi
9808 <
9809 < fi
9810 <
9811 < if test "x$LEX" != "x:"; then
9812 <  echo "$as_me:$LINENO: checking lex output file root" >&5
9813 < echo $ECHO_N "checking lex output file root... $ECHO_C" >&6
9814 < if test "${ac_cv_prog_lex_root+set}" = set; then
9815 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9816 < else
9817 <  # The minimal lex program is just a single line: %%.  But some broken lexes
9818 < # (Solaris, I think it was) want two %% lines, so accommodate them.
9819 < cat >conftest.l <<_ACEOF
9820 < %%
9821 < %%
9822 < _ACEOF
9823 < { (eval echo "$as_me:$LINENO: \"$LEX conftest.l\"") >&5
9824 <  (eval $LEX conftest.l) 2>&5
9825 <  ac_status=$?
9826 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9827 <  (exit $ac_status); }
9828 < if test -f lex.yy.c; then
9829 <  ac_cv_prog_lex_root=lex.yy
9830 < elif test -f lexyy.c; then
9831 <  ac_cv_prog_lex_root=lexyy
9832 < else
9833 <  { { echo "$as_me:$LINENO: error: cannot find output from $LEX; giving up" >&5
9834 < echo "$as_me: error: cannot find output from $LEX; giving up" >&2;}
9835 <   { (exit 1); exit 1; }; }
9836 < fi
9837 < fi
9838 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_root" >&5
9839 < echo "${ECHO_T}$ac_cv_prog_lex_root" >&6
9840 < rm -f conftest.l
9841 < LEX_OUTPUT_ROOT=$ac_cv_prog_lex_root
9842 <
9843 < echo "$as_me:$LINENO: checking whether yytext is a pointer" >&5
9844 < echo $ECHO_N "checking whether yytext is a pointer... $ECHO_C" >&6
9845 < if test "${ac_cv_prog_lex_yytext_pointer+set}" = set; then
9846 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9847 < else
9848 <  # POSIX says lex can declare yytext either as a pointer or an array; the
9849 < # default is implementation-dependent. Figure out which it is, since
9850 < # not all implementations provide the %pointer and %array declarations.
9851 < ac_cv_prog_lex_yytext_pointer=no
9852 < echo 'extern char *yytext;' >>$LEX_OUTPUT_ROOT.c
9853 < ac_save_LIBS=$LIBS
9854 < LIBS="$LIBS $LEXLIB"
9855 < cat >conftest.$ac_ext <<_ACEOF
9856 < `cat $LEX_OUTPUT_ROOT.c`
9857 < _ACEOF
9858 < rm -f conftest.$ac_objext conftest$ac_exeext
9859 < if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
9860 <  (eval $ac_link) 2>conftest.er1
9861 <  ac_status=$?
9862 <  grep -v '^ *+' conftest.er1 >conftest.err
9863 <  rm -f conftest.er1
9864 <  cat conftest.err >&5
9865 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9866 <  (exit $ac_status); } &&
9867 <         { ac_try='test -z "$ac_c_werror_flag"
9868 <                         || test ! -s conftest.err'
9869 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9870 <  (eval $ac_try) 2>&5
9871 <  ac_status=$?
9872 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9873 <  (exit $ac_status); }; } &&
9874 <         { ac_try='test -s conftest$ac_exeext'
9875 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
9876 <  (eval $ac_try) 2>&5
9877 <  ac_status=$?
9878 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9879 <  (exit $ac_status); }; }; then
9880 <  ac_cv_prog_lex_yytext_pointer=yes
9881 < else
9882 <  echo "$as_me: failed program was:" >&5
9883 < sed 's/^/| /' conftest.$ac_ext >&5
9884 <
9885 < fi
9886 < rm -f conftest.err conftest.$ac_objext \
9887 <      conftest$ac_exeext conftest.$ac_ext
9888 < LIBS=$ac_save_LIBS
9889 < rm -f "${LEX_OUTPUT_ROOT}.c"
9890 <
9891 < fi
9892 < echo "$as_me:$LINENO: result: $ac_cv_prog_lex_yytext_pointer" >&5
9893 < echo "${ECHO_T}$ac_cv_prog_lex_yytext_pointer" >&6
9894 < if test $ac_cv_prog_lex_yytext_pointer = yes; then
9895 <
9896 < cat >>confdefs.h <<\_ACEOF
9897 < #define YYTEXT_POINTER 1
9898 < _ACEOF
9899 <
9900 < fi
9901 <
9902 < fi
9903 <
9904 <   # Extract the first word of "perl", so it can be a program name with args.
9905 < set dummy perl; ac_word=$2
9906 < echo "$as_me:$LINENO: checking for $ac_word" >&5
9907 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9908 < if test "${ac_cv_path_PERLINTERP+set}" = set; then
9909 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9910 < else
9911 <  case $PERLINTERP in
9912 <  [\\/]* | ?:[\\/]*)
9913 <  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
9914 <  ;;
9915 <  *)
9916 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9917 < for as_dir in $PATH
9918 < do
9919 <  IFS=$as_save_IFS
9920 <  test -z "$as_dir" && as_dir=.
9921 <  for ac_exec_ext in '' $ac_executable_extensions; do
9922 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9923 <    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
9924 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9925 <    break 2
9926 <  fi
9927 < done
9928 < done
9929 <
9930 <  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
9931 <  ;;
9932 < esac
9933 < fi
9934 < PERLINTERP=$ac_cv_path_PERLINTERP
9935 <
9936 < if test -n "$PERLINTERP"; then
9937 <  echo "$as_me:$LINENO: result: $PERLINTERP" >&5
9938 < echo "${ECHO_T}$PERLINTERP" >&6
9939 < else
9940 <  echo "$as_me:$LINENO: result: no" >&5
9941 < echo "${ECHO_T}no" >&6
9942 < fi
9943 <
9944 <   ac_cv_path_perlinterp="$PERLINTERP"
9945 <   _sHpB='#!'
9946 <
9947 <
9948 < # Check whether --with-perl-shebang or --without-perl-shebang was given.
9949 < if test "${with_perl_shebang+set}" = set; then
9950 <  withval="$with_perl_shebang"
9951 <  opt_perl_shebang="$withval"
9952 < else
9953 <                opt_perl_shebang="not_set"
9954 < fi;
9955 <   echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
9956 < echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6
9957 < if test "${ax_cv_opt_perl_shebang+set}" = set; then
9958 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9959 < else
9960 <   case "$opt_perl_shebang" in
9961 <                      not_set  ) ax_cv_opt_perl_shebang=''
9962 <                               ;;
9963 <                         *     )
9964 <        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
9965 <                    esac
9966 <
9967 < fi
9968 < echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
9969 < echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6
9970 <   if test "A$ax_cv_opt_perl_shebang" != "A"
9971 <     then
9972 <       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
9973 <       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
9974 <              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
9975 < echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
9976 <
9977 < # Automatic detection of sharpbang formula starts here
9978 <     else
9979 <   _somian_shbangperl=`$PERLINTERP -V:startperl`
9980 <   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
9981 <   echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
9982 < echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6
9983 < if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
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 <  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
12850 <        if test "x$_somian_kspb_perl" == x
12851 <          then _somian_ksbp_warn_empty='durnit'
12852 <          else
12853 <          case "A$_somian_kspb_perl" in
12854 <                 A#!*perl* )
12855 <           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
9993 <                        ;;
9994 <                     A*    )  _somian_ksbp_warn_defau='trouble'
9995 <                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
9996 <          esac
9997 <        fi
12849 >  echo 'void f(){}' > conftest.cpp
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
12854 > fi
12855 > rm -f conftest*
12856  
12857   fi
12858 < echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
12859 < echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6
12860 < # The above prints Checking ... result message to user.
12861 <   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
12858 > echo "$as_me:$LINENO: result: $ac_m_cpu_powerpc" >&5
12859 > echo "${ECHO_T}$ac_m_cpu_powerpc" >&6
12860 > if test "$ac_m_cpu_powerpc" = yes; then
12861 >        :
12862 >        CPU_FLAGS=-mcpu=powerpc
12863 > else
12864 >        :
12865  
12866 <    if test A${_somian_ksbp_warn_empty+set} == Aset
10006 <      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
10007 < echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
10008 <    fi
10009 < # Inform user after printing result value
10010 <    if test A${_somian_ksbp_warn_defau+set} == Aset
10011 <      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
10012 < echo "$as_me: Maybe Not good -" >&6;}
10013 <           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
10014 < echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
10015 <      else { echo "$as_me:$LINENO: OK Good result - " >&5
10016 < echo "$as_me: OK Good result - " >&6;}
10017 <           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
10018 < echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
10019 <    fi
10020 <  fi
12866 > fi
12867  
12868 < # Extract the first word of "ar", so it can be a program name with args.
12869 < set dummy ar; ac_word=$2
12870 < echo "$as_me:$LINENO: checking for $ac_word" >&5
12871 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
12872 < if test "${ac_cv_prog_AR+set}" = set; then
12868 >                fi
12869 >                if test -z "$CPU_FLAGS"; then
12870 >
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
10035 <  IFS=$as_save_IFS
10036 <  test -z "$as_dir" && as_dir=.
10037 <  for ac_exec_ext in '' $ac_executable_extensions; do
10038 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10039 <    ac_cv_prog_AR="ar"
10040 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10041 <    break 2
10042 <  fi
10043 < done
10044 < done
12881 >        ac_m_powerpc=no
12882 > fi
12883 > rm -f conftest*
12884  
10046  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;}
10061 <   { (exit 1); exit 1; }; }
10062 <  cat >confcache <<\_ACEOF
10063 < # This file is a shell script that caches the results of configure
10064 < # tests run on this system so they can be shared between configure
10065 < # scripts and configure runs, see configure's option --config-cache.
10066 < # It is not useful on other systems.  If it contains results you don't
10067 < # want to keep, you may remove or edit it.
10068 < #
10069 < # config.status only pays attention to the cache file if you give it
10070 < # the --recheck option to rerun configure.
10071 < #
10072 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
10073 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
10074 < # 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=\ *)
10087 <      # `set' does not quote correctly, so add quotes (double-quote
10088 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
10089 <      sed -n \
10090 <        "s/'/'\\\\''/g;
10091 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
10092 <      ;;
10093 <    *)
10094 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
10095 <      sed -n \
10096 <        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
10097 <      ;;
10098 <    esac;
10099 < } |
10100 <  sed '
10101 <     t clear
10102 <     : clear
10103 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
10104 <     t end
10105 <     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
10106 <     : end' >>confcache
10107 < if diff $cache_file confcache >/dev/null 2>&1; then :; else
10108 <  if test -w $cache_file; then
10109 <    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
10110 <    cat confcache >$cache_file
10111 <  else
10112 <    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
10114 fi
10115 rm -f confcache
10116  exit 1
10117 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 <  *)
10131 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10132 < for as_dir in $PATH
10133 < do
10134 <  IFS=$as_save_IFS
10135 <  test -z "$as_dir" && as_dir=.
10136 <  for ac_exec_ext in '' $ac_executable_extensions; do
10137 <  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10138 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
10139 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10140 <    break 2
10141 <  fi
10142 < done
10143 < done
10144 <
10145 <  ;;
10146 < 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  
10150 if test -n "$PS"; then
10151  echo "$as_me:$LINENO: result: $PS" >&5
10152 echo "${ECHO_T}$PS" >&6
10153 else
10154  echo "$as_me:$LINENO: result: no" >&5
10155 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  
10158 echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
10159 echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6
10160 if test "${ac_cv_prog_ps_syntax+set}" = set; then
10161  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
10172 <                ac_cv_prog_ps_ef=no
10173 <        fi
10174 <        if test "$ac_cv_prog_ps_ax" = yes; then
10175 <                ac_cv_prog_ps_syntax=BSD
10176 <        else
10177 <                if test "$ac_cv_prog_ps_ef" = yes; then
10178 <                        ac_cv_prog_ps_syntax=POSIX
10179 <                else
10180 <                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
10181 < echo "$as_me: error: Could not determine ps syntax" >&2;}
10182 <   { (exit 1); exit 1; }; }
10183 <                fi
10184 <        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
10187 echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
10188 echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6
12949  
12950  
12951 < cat >>confdefs.h <<_ACEOF
10192 < #define PSCOMMAND $PS
10193 < _ACEOF
12951 > fi
12952  
12953 +     ;;
12954 + esac
12955  
12956 +
12957   cat >>confdefs.h <<\_ACEOF
12958   #define OBAPI
12959   _ACEOF
12960  
12961  
12962  
10202 if test "$ac_cv_prog_ps_syntax" = BSD; then
12963  
10204 cat >>confdefs.h <<\_ACEOF
10205 #define PSTYPE_IS_BSD 1
10206 _ACEOF
10207
10208 else
10209   if test "$ac_cv_prog_ps_syntax" = POSIX; then
10210
10211 cat >>confdefs.h <<\_ACEOF
10212 #define PSTYPE_IS_POSIX 1
10213 _ACEOF
10214
10215   else
10216       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
10217 echo "$as_me: error: Unknown ps syntax type!" >&2;}
10218   { (exit 1); exit 1; }; }
10219   fi
10220 fi
10221
10222
12964   # Check whether --with-mpi or --without-mpi was given.
12965   if test "${with_mpi+set}" = set; then
12966    withval="$with_mpi"
# Line 10245 | 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 10273 | 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 10302 | 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 10310 | 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 10334 | 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 10382 | 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 10404 | 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 10434 | 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
10455 $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 10460 | 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 10475 | 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 10519 | 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 10546 | 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 10576 | 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
10597
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 10618 | 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 10695 | Line 13499 | fi
13499  
13500  
13501  
10698 USE_CGAL=no
10699 cgal_makefile=auto
10700
10701 # Check whether --with-cgal-makefile or --without-cgal-makefile was given.
10702 if test "${with_cgal_makefile+set}" = set; then
10703  withval="$with_cgal_makefile"
10704  cgal_makefile="$withval"
10705 fi;
10706
10707 if test "x$cgal_makefile" != xno; then
10708
10709  if test "x$cgal_makefile" = xauto -a "x$CGAL_MAKEFILE" != x; then
10710    cgal_makefile="$CGAL_MAKEFILE"
10711  fi
10712
10713  echo "$as_me:$LINENO: checking for cgal_makefile: $cgal_makefile" >&5
10714 echo $ECHO_N "checking for cgal_makefile: $cgal_makefile... $ECHO_C" >&6
10715
10716  if test -f "$cgal_makefile"; then
10717
10718    cat >config.tmp.Makefile <<EOF
10719 include $cgal_makefile
10720 default:
10721        @echo CGAL_OS_COMPILER=\"\${CGAL_OS_COMPILER}\" >config.tmp.cgalvariables
10722        @echo CGAL_INCLDIR=\"\${CGAL_INCL_DIR}\" >>config.tmp.cgalvariables
10723        @echo CGAL_INCLCONFDIR=\"\${CGAL_INCL_CONF_DIR}\" >>config.tmp.cgalvariables
10724        @echo CGAL_LIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
10725        @echo CGAL_RLIBDIR=\"\${CGAL_LIB_DIR}/\${CGAL_OS_COMPILER}\" >>config.tmp.cgalvariables
10726        @echo CGAL_CXXFLAGS=\"\${CGAL_CXXFLAGS}\" >>config.tmp.cgalvariables
10727        @echo GMP_INCLDIR=\"\${GMP_INCL_DIR}\" >>config.tmp.cgalvariables
10728        @echo GMP_LIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
10729        @echo GMP_RLIBDIR=\"\${GMP_LIB_DIR}\" >>config.tmp.cgalvariables
10730        @echo LEDA_INCLDIR=\"\${LEDA_INCL_DIR}\" >>config.tmp.cgalvariables
10731        @echo LEDA_LIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
10732        @echo LEDA_RLIBDIR=\"\${LEDA_LIB_DIR}\" >>config.tmp.cgalvariables
10733 EOF
10734
10735    make -s -f config.tmp.Makefile
10736    . config.tmp.cgalvariables
10737
10738    rm -f config.tmp.Makefile config.tmp.cgalvariables
10739
10740    if test "x$CGAL_INCLDIR" = "x"; then
10741      CGAL_INCLDIR=""
10742    fi
10743
10744    if test "x$CGAL_LIBDIR" = "x"; then
10745      CGAL_LIBDIR=""
10746    fi
10747
10748    if test "x$CGAL_RLIBDIR" = "x"; then
10749      CGAL_RLIBDIR=""
10750    fi
10751
10752    if test "x$LEDA_INCLDIR" = "x"; then
10753      LEDA_INCLDIR=""
10754    fi
10755
10756    if test "x$LEDA_LIBDIR" = "x"; then
10757      LEDA_LIBDIR=""
10758    fi
10759
10760    if test "x$LEDA_RLIBDIR" = "x"; then
10761      LEDA_RLIBDIR=""
10762    fi
10763
10764    if test "x$GMP_INCLDIR" = "x"; then
10765      GMP_INCLDIR=""
10766    fi
10767
10768    if test "x$GMP_LIBDIR" = "x"; then
10769      GMP_LIBDIR=""
10770    fi
10771
10772    if test "x$GMP_RLIBDIR" = "x"; then
10773      GMP_RLIBDIR=""
10774    fi
10775
10776    echo "$as_me:$LINENO: result: CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&5
10777 echo "${ECHO_T}CGAL_OS_COMPILER=   $CGAL_OS_COMPILER" >&6
10778    echo "$as_me:$LINENO: result: CGAL_INCLDIR=       $CGAL_INCLDIR" >&5
10779 echo "${ECHO_T}CGAL_INCLDIR=       $CGAL_INCLDIR" >&6
10780    echo "$as_me:$LINENO: result: CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&5
10781 echo "${ECHO_T}CGAL_INCLCONFDIR=   $CGAL_INCLCONFDIR" >&6
10782    echo "$as_me:$LINENO: result: CGAL_LIBDIR=        $CGAL_LIBDIR" >&5
10783 echo "${ECHO_T}CGAL_LIBDIR=        $CGAL_LIBDIR" >&6
10784    echo "$as_me:$LINENO: result: CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&5
10785 echo "${ECHO_T}CGAL_CXXFLAGS=      $CGAL_CXXFLAGS" >&6
10786    echo "$as_me:$LINENO: result: LEDA_INCLDIR=       $LEDA_INCLDIR" >&5
10787 echo "${ECHO_T}LEDA_INCLDIR=       $LEDA_INCLDIR" >&6
10788    echo "$as_me:$LINENO: result: LEDA_LIBDIR=        $LEDA_LIBDIR" >&5
10789 echo "${ECHO_T}LEDA_LIBDIR=        $LEDA_LIBDIR" >&6
10790    echo "$as_me:$LINENO: result: GMP_INCLDIR=        $GMP_INCLDIR" >&5
10791 echo "${ECHO_T}GMP_INCLDIR=        $GMP_INCLDIR" >&6
10792    echo "$as_me:$LINENO: result: GMP_LIBDIR=         $GMP_LIBDIR" >&5
10793 echo "${ECHO_T}GMP_LIBDIR=         $GMP_LIBDIR" >&6
10794
10795    ac_ext=cc
10796 ac_cpp='$CXXCPP $CPPFLAGS'
10797 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
10798 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
10799 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
10800
10801    save_CXXFLAGS="$CXXFLAGS"
10802    CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
10803    if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
10804  echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
10805 echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
10806 if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
10807  echo $ECHO_N "(cached) $ECHO_C" >&6
10808 fi
10809 echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
10810 echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
10811 else
10812  # Is the header compilable?
10813 echo "$as_me:$LINENO: checking CGAL/Cartesian.h usability" >&5
10814 echo $ECHO_N "checking CGAL/Cartesian.h usability... $ECHO_C" >&6
10815 cat >conftest.$ac_ext <<_ACEOF
10816 /* confdefs.h.  */
10817 _ACEOF
10818 cat confdefs.h >>conftest.$ac_ext
10819 cat >>conftest.$ac_ext <<_ACEOF
10820 /* end confdefs.h.  */
10821 $ac_includes_default
10822 #include <CGAL/Cartesian.h>
10823 _ACEOF
10824 rm -f conftest.$ac_objext
10825 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10826  (eval $ac_compile) 2>conftest.er1
10827  ac_status=$?
10828  grep -v '^ *+' conftest.er1 >conftest.err
10829  rm -f conftest.er1
10830  cat conftest.err >&5
10831  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10832  (exit $ac_status); } &&
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=$?
10838  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10839  (exit $ac_status); }; } &&
10840         { ac_try='test -s conftest.$ac_objext'
10841  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10842  (eval $ac_try) 2>&5
10843  ac_status=$?
10844  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10845  (exit $ac_status); }; }; then
10846  ac_header_compiler=yes
10847 else
10848  echo "$as_me: failed program was:" >&5
10849 sed 's/^/| /' conftest.$ac_ext >&5
10850
10851 ac_header_compiler=no
10852 fi
10853 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
10854 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10855 echo "${ECHO_T}$ac_header_compiler" >&6
10856
10857 # Is the header present?
10858 echo "$as_me:$LINENO: checking CGAL/Cartesian.h presence" >&5
10859 echo $ECHO_N "checking CGAL/Cartesian.h presence... $ECHO_C" >&6
10860 cat >conftest.$ac_ext <<_ACEOF
10861 /* confdefs.h.  */
10862 _ACEOF
10863 cat confdefs.h >>conftest.$ac_ext
10864 cat >>conftest.$ac_ext <<_ACEOF
10865 /* end confdefs.h.  */
10866 #include <CGAL/Cartesian.h>
10867 _ACEOF
10868 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
10869  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
10870  ac_status=$?
10871  grep -v '^ *+' conftest.er1 >conftest.err
10872  rm -f conftest.er1
10873  cat conftest.err >&5
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_cxx_preproc_warn_flag
10878    ac_cpp_err=$ac_cpp_err$ac_cxx_werror_flag
10879  else
10880    ac_cpp_err=
10881  fi
10882 else
10883  ac_cpp_err=yes
10884 fi
10885 if test -z "$ac_cpp_err"; then
10886  ac_header_preproc=yes
10887 else
10888  echo "$as_me: failed program was:" >&5
10889 sed 's/^/| /' conftest.$ac_ext >&5
10890
10891  ac_header_preproc=no
10892 fi
10893 rm -f conftest.err conftest.$ac_ext
10894 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10895 echo "${ECHO_T}$ac_header_preproc" >&6
10896
10897 # So?  What about this header?
10898 case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
10899  yes:no: )
10900    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&5
10901 echo "$as_me: WARNING: CGAL/Cartesian.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
10902    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&5
10903 echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the compiler's result" >&2;}
10904    ac_header_preproc=yes
10905    ;;
10906  no:yes:* )
10907    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&5
10908 echo "$as_me: WARNING: CGAL/Cartesian.h: present but cannot be compiled" >&2;}
10909    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&5
10910 echo "$as_me: WARNING: CGAL/Cartesian.h:     check for missing prerequisite headers?" >&2;}
10911    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&5
10912 echo "$as_me: WARNING: CGAL/Cartesian.h: see the Autoconf documentation" >&2;}
10913    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&5
10914 echo "$as_me: WARNING: CGAL/Cartesian.h:     section \"Present But Cannot Be Compiled\"" >&2;}
10915    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&5
10916 echo "$as_me: WARNING: CGAL/Cartesian.h: proceeding with the preprocessor's result" >&2;}
10917    { echo "$as_me:$LINENO: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&5
10918 echo "$as_me: WARNING: CGAL/Cartesian.h: in the future, the compiler will take precedence" >&2;}
10919    (
10920      cat <<\_ASBOX
10921 ## ------------------------------ ##
10922 ## Report this to gezelter@nd.edu ##
10923 ## ------------------------------ ##
10924 _ASBOX
10925    ) |
10926      sed "s/^/$as_me: WARNING:     /" >&2
10927    ;;
10928 esac
10929 echo "$as_me:$LINENO: checking for CGAL/Cartesian.h" >&5
10930 echo $ECHO_N "checking for CGAL/Cartesian.h... $ECHO_C" >&6
10931 if test "${ac_cv_header_CGAL_Cartesian_h+set}" = set; then
10932  echo $ECHO_N "(cached) $ECHO_C" >&6
10933 else
10934  ac_cv_header_CGAL_Cartesian_h=$ac_header_preproc
10935 fi
10936 echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Cartesian_h" >&5
10937 echo "${ECHO_T}$ac_cv_header_CGAL_Cartesian_h" >&6
10938
10939 fi
10940 if test $ac_cv_header_CGAL_Cartesian_h = yes; then
10941  cgal=yes
10942 else
10943  cgal=no
10944 fi
10945
10946
10947    CXXFLAGS="$save_CXXFLAGS"
10948
10949    if test "x$cgal" = xyes; then
10950      echo "$as_me:$LINENO: checking for CGAL version" >&5
10951 echo $ECHO_N "checking for CGAL version... $ECHO_C" >&6
10952      LOCATION=${CGAL_INCLDIR}
10953      LOCATION=${LOCATION:-/usr/include}
10954      if test -f $LOCATION/CGAL/version.h; then
10955        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/version.h | sed 's/[^0-9\.]*//g'`
10956      else
10957        CGAL_VERSION=`grep '#define.*\<CGAL_VERSION\>.*' $LOCATION/CGAL/config.h | sed 's/[^0-9\.]*//g'`
10958      fi
10959      if echo $CGAL_VERSION | grep -q "^[3456789]"; then
10960        echo "$as_me:$LINENO: result: ($CGAL_VERSION) yes" >&5
10961 echo "${ECHO_T}($CGAL_VERSION) yes" >&6
10962      else
10963        echo "$as_me:$LINENO: result: ($CGAL_VERSION) no" >&5
10964 echo "${ECHO_T}($CGAL_VERSION) no" >&6
10965        cgal=no
10966      fi
10967    fi
10968
10969    if test "x$cgal" = xyes; then
10970      CGAL_LIBS="-lCGAL"
10971      echo "$as_me:$LINENO: checking whether CGAL uses LEDA" >&5
10972 echo $ECHO_N "checking whether CGAL uses LEDA... $ECHO_C" >&6
10973      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_LEDA; then
10974        CGAL_USES_LEDA=yes
10975        echo "$as_me:$LINENO: result: yes" >&5
10976 echo "${ECHO_T}yes" >&6
10977        CGAL_DEFINES="-DCGAL_USE_LEDA -DLEDA_PREFIX"
10978      else
10979        echo "$as_me:$LINENO: result: no" >&5
10980 echo "${ECHO_T}no" >&6
10981        CGAL_USES_LEDA=no
10982      fi
10983
10984      echo "$as_me:$LINENO: checking whether CGAL uses GMP" >&5
10985 echo $ECHO_N "checking whether CGAL uses GMP... $ECHO_C" >&6
10986      if echo $CGAL_CXXFLAGS | grep -q -- -DCGAL_USE_GMP; then
10987        CGAL_USES_GMP=yes
10988        echo "$as_me:$LINENO: result: yes" >&5
10989 echo "${ECHO_T}yes" >&6
10990        CGAL_DEFINES="-DCGAL_USE_GMP $CGAL_DEFINES"
10991      else
10992        echo "$as_me:$LINENO: result: no" >&5
10993 echo "${ECHO_T}no" >&6
10994        CGAL_USES_GMP=no
10995      fi
10996
10997      CGAL_LIBS="$CGAL_LIBS -lm"
10998
10999      CGAL_CXXFLAGS="-ftemplate-depth-50"
11000
11001      echo "$as_me:$LINENO: result: CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&5
11002 echo "${ECHO_T}CGAL_USES_LEDA=     $CGAL_USES_LEDA" >&6
11003      echo "$as_me:$LINENO: result: CGAL_USES_GMP =     $CGAL_USES_GMP" >&5
11004 echo "${ECHO_T}CGAL_USES_GMP =     $CGAL_USES_GMP" >&6
11005      echo "$as_me:$LINENO: result: CGAL_INCLDIR  =     $CGAL_INCLDIR" >&5
11006 echo "${ECHO_T}CGAL_INCLDIR  =     $CGAL_INCLDIR" >&6
11007      echo "$as_me:$LINENO: result: CGAL_LIBDIR   =     $CGAL_LIBDIR" >&5
11008 echo "${ECHO_T}CGAL_LIBDIR   =     $CGAL_LIBDIR" >&6
11009      echo "$as_me:$LINENO: result: CGAL_DEFINES  =     $CGAL_DEFINES" >&5
11010 echo "${ECHO_T}CGAL_DEFINES  =     $CGAL_DEFINES" >&6
11011      echo "$as_me:$LINENO: result: CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&5
11012 echo "${ECHO_T}CGAL_CXXFLAGS =     $CGAL_CXXFLAGS" >&6
11013      echo "$as_me:$LINENO: result: CGAL_LIBS     =     $CGAL_LIBS" >&5
11014 echo "${ECHO_T}CGAL_LIBS     =     $CGAL_LIBS" >&6
11015    fi
11016
11017    if test "x$cgal" = xyes; then
11018      save_LIBS="$LIBS"
11019      LIBS="$LIBS -L$CGAL_LIBDIR"
11020      if test "x$CGAL_USES_LEDA" = xyes; then
11021        LIBS="-lL $LIBS -L$LEDA_LIBDIR"
11022      fi
11023      # if test "x$CGAL_USES_GMP" = xyes; then
11024      #   LIBS="-lgmp $LIBS $GMP_LIBDIR"
11025      # fi
11026      echo "$as_me:$LINENO: checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL" >&5
11027 echo $ECHO_N "checking for ::CGAL::Cartesian<int>::Point_2 in -lCGAL... $ECHO_C" >&6
11028 save_CXXFLAGS_CHECK_CXX_LIB="$CXXFLAGS"
11029 CXXFLAGS="$CXXFLAGS -I$CGAL_INCLDIR -I$CGAL_INCLCONFDIR"
11030 save_LIBS_CHECK_CXX_LIB="$LIBS"
11031 LIBS="-lCGAL  $LIBS"
11032 cat >conftest.$ac_ext <<_ACEOF
11033 /* confdefs.h.  */
11034 _ACEOF
11035 cat confdefs.h >>conftest.$ac_ext
11036 cat >>conftest.$ac_ext <<_ACEOF
11037 /* end confdefs.h.  */
11038 #include <CGAL/Cartesian.h>
11039 int
11040 main ()
11041 {
11042 ::CGAL::Cartesian<int>::Point_2 P
11043  ;
11044  return 0;
11045 }
11046 _ACEOF
11047 rm -f conftest.$ac_objext conftest$ac_exeext
11048 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
11049  (eval $ac_link) 2>conftest.er1
11050  ac_status=$?
11051  grep -v '^ *+' conftest.er1 >conftest.err
11052  rm -f conftest.er1
11053  cat conftest.err >&5
11054  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11055  (exit $ac_status); } &&
11056         { ac_try='test -z "$ac_cxx_werror_flag"
11057                         || test ! -s conftest.err'
11058  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11059  (eval $ac_try) 2>&5
11060  ac_status=$?
11061  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11062  (exit $ac_status); }; } &&
11063         { ac_try='test -s conftest$ac_exeext'
11064  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11065  (eval $ac_try) 2>&5
11066  ac_status=$?
11067  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11068  (exit $ac_status); }; }; then
11069  echo "$as_me:$LINENO: result: yes" >&5
11070 echo "${ECHO_T}yes" >&6
11071 cgal=yes
11072 else
11073  echo "$as_me: failed program was:" >&5
11074 sed 's/^/| /' conftest.$ac_ext >&5
11075
11076 echo "$as_me:$LINENO: result: no" >&5
11077 echo "${ECHO_T}no" >&6
11078 cgal=no
11079 fi
11080 rm -f conftest.err conftest.$ac_objext \
11081      conftest$ac_exeext conftest.$ac_ext
11082 CXXFLAGS="$save_CXXFLAGS_CHECK_CXX_LIB"
11083 LIBS="$save_LIBS_CHECK_CXX_LIB"
11084      LIBS="$save_LIBS"
11085    fi
11086
11087  fi
11088  ac_ext=c
11089 ac_cpp='$CPP $CPPFLAGS'
11090 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11091 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11092 ac_compiler_gnu=$ac_cv_c_compiler_gnu
11093
11094
11095 fi
11096
11097 if test "x$cgal" = xyes; then
11098  USE_CGAL=yes
11099
11100 cat >>confdefs.h <<\_ACEOF
11101 #define HAVE_CGAL 1
11102 _ACEOF
11103
11104
11105 cat >>confdefs.h <<_ACEOF
11106 #define CGAL_VERSION $CGAL_VERSION
11107 _ACEOF
11108
11109  if ! echo $CGAL_VERSION | grep -q "^3.0"; then
11110    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
11111 echo "$as_me: WARNING: *****************************************************" >&2;}
11112    { echo "$as_me:$LINENO: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&5
11113 echo "$as_me: WARNING: *** Warning: Your CGAL version is newer than the  ***" >&2;}
11114    { echo "$as_me:$LINENO: WARNING: *** supported versions. It may still work though. ***" >&5
11115 echo "$as_me: WARNING: *** supported versions. It may still work though. ***" >&2;}
11116    { echo "$as_me:$LINENO: WARNING: *****************************************************" >&5
11117 echo "$as_me: WARNING: *****************************************************" >&2;}
11118  fi
11119 else
11120   if test "x$cgal_makefile" != xno; then
11121    echo "$as_me:$LINENO: result: No CGAL support. These are not the droids you want." >&5
11122 echo "${ECHO_T}No CGAL support. These are not the droids you want." >&6
11123  fi
11124  CGAL_INCLDIR=
11125  CGAL_LIBDIR=
11126  CGAL_RLIBDIR=
11127  CGAL_DEFINES=
11128  CGAL_CXXFLAGS=
11129  CGAL_LIBS=
11130 fi
11131
11132
11133 CGAL_INC_DIR="${CGAL_INCLDIR} ${CGAL_INCLCONFDIR}"
11134
11135 CGAL_LIB_DIR=${CGAL_LIBDIR}
11136
11137 CGAL_RLIB_DIR=${CGAL_RLIBDIR}
11138
11139
11140
11141
11142
11143
11144
13502   # Check whether --enable-doxygen or --disable-doxygen was given.
13503   if test "${enable_doxygen+set}" = set; then
13504    enableval="$enable_doxygen"
# Line 11283 | Line 13640 | fi
13640  
13641  
13642  
11286 OBJEXT=".$OBJEXT"
13643  
11288 OOPSE=oopse
13644  
11290 if test "x${prefix}" = "xNONE"
11291 then
11292  OOPSE_HOME=${ac_default_prefix}/oopse
11293 else
11294  OOPSE_HOME=${prefix}/oopse
11295 fi
11296 # Check whether --enable-oopse-home or --disable-oopse-home was given.
11297 if test "${enable_oopse_home+set}" = set; then
11298  enableval="$enable_oopse_home"
11299  OOPSE_HOME="${enableval}"
11300 fi;
13645  
11302 case "x$INSTALL" in
11303   x/*) ;;
11304   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
11305 esac
13646  
11307 MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
13647  
11309 CFLAGS=${CFLAGS-""}
11310 CXXFLAGS=${CXXFLAGS-""}
11311 CPPFLAGS=${CPPFLAGS-""}
11312 FFLAGS=${FFLAGS-""}
11313 F90FLAGS=${F90FLAGS-""}
11314 LDFLAGS=${LDFLAGS-""}
11315 DEBUG=${DEBUG-"-g"}
13648  
11317 case $debug in
11318  1)
11319     FFLAGS="$DEBUG $FFLAGS"
11320     F90FLAGS="$DEBUG $F90FLAGS"
11321     ;;
11322  *)
11323     ;;
11324 esac
13649  
13650  
13651  
13652  
13653  
13654  
13655 <
11332 <
11333 <
11334 <
11335 <
11336 <
11337 <
11338 <
11339 <
11340 <
11341 <
11342 <
11343 <          ac_config_headers="$ac_config_headers src/config.h"
11344 <
11345 <                                        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 11707 | 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 11770 | 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 11875 | 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" ;;
11878  "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 11964 | 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
11967 s,@PROGNAME@,$PROGNAME,;t t
11968 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 11974 | 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
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
11989 s,@OOPSE_TEMPLATE_FLAGS@,$OOPSE_TEMPLATE_FLAGS,;t t
11990 s,@EXTRA_CC_FLAG@,$EXTRA_CC_FLAG,;t t
11991 s,@F90@,$F90,;t t
11992 s,@F90FLAGS@,$F90FLAGS,;t t
11993 s,@ac_ct_F90@,$ac_ct_F90,;t t
11994 s,@PREPFLAG@,$PREPFLAG,;t t
11995 s,@PREPDEFFLAG@,$PREPDEFFLAG,;t t
11996 s,@F90LIBS@,$F90LIBS,;t t
11997 s,@F90_FUNC@,$F90_FUNC,;t t
11998 s,@F90_FUNC_@,$F90_FUNC_,;t t
11999 s,@MOD@,$MOD,;t t
12000 s,@F90_WORK_FILES_ARG@,$F90_WORK_FILES_ARG,;t t
12001 s,@MODDIRFLAG@,$MODDIRFLAG,;t t
12002 s,@F90MODINCSPEC@,$F90MODINCSPEC,;t t
12003 s,@F90_MODULE_NAMES@,$F90_MODULE_NAMES,;t t
12004 s,@CXXCPP@,$CXXCPP,;t t
12005 s,@LIBOBJS@,$LIBOBJS,;t t
12006 s,@__func__@,$__func__,;t t
12007 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12008 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12009 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
12014 s,@YACC@,$YACC,;t t
12015 s,@LEX@,$LEX,;t t
12016 s,@LEXLIB@,$LEXLIB,;t t
12017 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
12028 s,@USE_CGAL@,$USE_CGAL,;t t
12029 s,@CGAL_INC_DIR@,$CGAL_INC_DIR,;t t
12030 s,@CGAL_LIB_DIR@,$CGAL_LIB_DIR,;t t
12031 s,@CGAL_RLIB_DIR@,$CGAL_RLIB_DIR,;t t
12032 s,@CGAL_DEFINES@,$CGAL_DEFINES,;t t
12033 s,@CGAL_CXXFLAGS@,$CGAL_CXXFLAGS,;t t
12034 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 12043 | 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
12046 s,@FFLAGS@,$FFLAGS,;t t
14351   s,@LTLIBOBJS@,$LTLIBOBJS,;t t
14352   CEOF
14353  
# Line 12285 | 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/* ;;
12288    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